private static async Task ProcessComandsAsync(DropConfiguration configuration, DataPackageView dataview)
{
if (configuration.OnDropDataViewCommand != null)
{
configuration.OnDropDataViewCommand.Execute(dataview);
}
if (dataview.Contains(StandardDataFormats.ApplicationLink) && configuration.OnDropApplicationLinkCommand != null)
{
var uri = await dataview.GetApplicationLinkAsync();
configuration.OnDropApplicationLinkCommand.Execute(uri);
}
if (dataview.Contains(StandardDataFormats.Bitmap) && configuration.OnDropBitmapCommand != null)
{
var stream = await dataview.GetBitmapAsync();
configuration.OnDropBitmapCommand.Execute(stream);
}
if (dataview.Contains(StandardDataFormats.Html) && configuration.OnDropHtmlCommand != null)
{
var html = await dataview.GetHtmlFormatAsync();
configuration.OnDropHtmlCommand.Execute(html);
}
if (dataview.Contains(StandardDataFormats.Rtf) && configuration.OnDropRtfCommand != null)
{
var rtf = await dataview.GetRtfAsync();
configuration.OnDropRtfCommand.Execute(rtf);
}
if (dataview.Contains(StandardDataFormats.StorageItems) && configuration.OnDropStorageItemsCommand != null)
{
var storageItems = await dataview.GetStorageItemsAsync();
configuration.OnDropStorageItemsCommand.Execute(storageItems);
}
if (dataview.Contains(StandardDataFormats.Text) && configuration.OnDropTextCommand != null)
{
var text = await dataview.GetTextAsync();
configuration.OnDropTextCommand.Execute(text);
}
if (dataview.Contains(StandardDataFormats.WebLink) && configuration.OnDropWebLinkCommand != null)
{
var uri = await dataview.GetWebLinkAsync();
configuration.OnDropWebLinkCommand.Execute(uri);
}
}
public async Task ProcessComandsAsync(DataPackageView dataview)
{
if (DropDataViewAction != null)
{
DropDataViewAction.Invoke(dataview);
}
if (dataview.Contains(StandardDataFormats.ApplicationLink) && DropApplicationLinkAction != null)
{
Uri uri = await dataview.GetApplicationLinkAsync();
DropApplicationLinkAction.Invoke(uri);
}
if (dataview.Contains(StandardDataFormats.Bitmap) && DropBitmapAction != null)
{
RandomAccessStreamReference stream = await dataview.GetBitmapAsync();
DropBitmapAction.Invoke(stream);
}
if (dataview.Contains(StandardDataFormats.Html) && DropHtmlAction != null)
{
string html = await dataview.GetHtmlFormatAsync();
DropHtmlAction.Invoke(html);
}
if (dataview.Contains(StandardDataFormats.Rtf) && DropRtfAction != null)
{
string rtf = await dataview.GetRtfAsync();
DropRtfAction.Invoke(rtf);
}
if (dataview.Contains(StandardDataFormats.StorageItems) && DropStorageItemsAction != null)
{
IReadOnlyList <IStorageItem> storageItems = await dataview.GetStorageItemsAsync();
DropStorageItemsAction.Invoke(storageItems);
}
if (dataview.Contains(StandardDataFormats.Text) && DropTextAction != null)
{
string text = await dataview.GetTextAsync();
DropTextAction.Invoke(text);
}
if (dataview.Contains(StandardDataFormats.WebLink) && DropWebLinkAction != null)
{
Uri uri = await dataview.GetWebLinkAsync();
DropWebLinkAction.Invoke(uri);
}
}
public async Task ProcessComandsAsync(DataPackageView dataview)
{
if (DropDataViewAction != null)
{
DropDataViewAction.Invoke(dataview);
}
if (dataview.Contains(StandardDataFormats.ApplicationLink) && DropApplicationLinkAction != null)
{
var uri = await dataview.GetApplicationLinkAsync();
DropApplicationLinkAction.Invoke(uri);
}
if (dataview.Contains(StandardDataFormats.Bitmap) && DropBitmapAction != null)
{
var stream = await dataview.GetBitmapAsync();
DropBitmapAction.Invoke(stream);
}
if (dataview.Contains(StandardDataFormats.Html) && DropHtmlAction != null)
{
var html = await dataview.GetHtmlFormatAsync();
DropHtmlAction.Invoke(html);
}
if (dataview.Contains(StandardDataFormats.Rtf) && DropRtfAction != null)
{
var rtf = await dataview.GetRtfAsync();
DropRtfAction.Invoke(rtf);
}
if (dataview.Contains(StandardDataFormats.StorageItems) && DropStorageItemsAction != null)
{
var storageItems = await dataview.GetStorageItemsAsync();
DropStorageItemsAction.Invoke(storageItems);
}
if (dataview.Contains(StandardDataFormats.Text) && DropTextAction != null)
{
var text = await dataview.GetTextAsync();
DropTextAction.Invoke(text);
}
if (dataview.Contains(StandardDataFormats.WebLink) && DropWebLinkAction != null)
{
var uri = await dataview.GetWebLinkAsync();
DropWebLinkAction.Invoke(uri);
}
}
internal static async Task <string> SetData(DataPackageView data)
{
string type = "";
if (data.Contains(StandardDataFormats.StorageItems))
{
var items = await data.GetStorageItemsAsync();
var files = items.Where(x => x is StorageFile).Select(x => x as StorageFile).ToList();
string url = "";
if ((files.Count == 1) &&
((files[0].FileType.ToLower() == ".html") /* Edge */ || (files[0].FileType.ToLower() == ".url") /* Chrome + Firefox */) &&
((url = await IsALink(files[0])) != ""))
{
SendDataTemporaryStorage.LaunchUri = new Uri(url);
SendDataTemporaryStorage.Text = url;
type = StandardDataFormats.WebLink;
}
else if ((files.Count == 0) && (items.Count == 1) && (items[0] is StorageFolder))
{
SendDataTemporaryStorage.Files = new List <IStorageItem>(items);
type = StandardDataFormats.StorageItems;
}
else
{
SendDataTemporaryStorage.Files = new List <IStorageItem>(files);
type = StandardDataFormats.StorageItems;
}
}
else if (data.Contains(StandardDataFormats.WebLink))
{
SendDataTemporaryStorage.LaunchUri = await data.GetWebLinkAsync();
SendDataTemporaryStorage.Text = SendDataTemporaryStorage.LaunchUri.OriginalString;
type = StandardDataFormats.WebLink;
}
else if (data.Contains(StandardDataFormats.ApplicationLink))
{
SendDataTemporaryStorage.LaunchUri = await data.GetApplicationLinkAsync();
SendDataTemporaryStorage.Text = SendDataTemporaryStorage.LaunchUri.OriginalString;
type = StandardDataFormats.ApplicationLink;
}
else if (data.Contains(StandardDataFormats.Text))
{
SendDataTemporaryStorage.Text = await data.GetTextAsync();
type = StandardDataFormats.Text;
}
return(type);
}
static public async Task <ClipboardDetectedEventArgs> CheckClipboard()
{
ClipboardDetectedEventArgs clipboardValue = null;
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.WebLink))
{
var uri = await dataPackageView.GetWebLinkAsync();
if (uri.OriginalString == prevContent)
{
return(null);
}
clipboardValue = ExtractNicoContentId(uri);
prevContent = uri.OriginalString;
}
else if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
if (prevContent == text)
{
return(null);
}
try
{
if (Uri.TryCreate(text, UriKind.Absolute, out var uri))
{
clipboardValue = ExtractNicoContentId(uri);
}
else
{
clipboardValue = ExtractNicoContentId(text);
}
}
catch
{
}
prevContent = text;
}
return(clipboardValue);
}
private async void HandleDataPackage(DataPackageView data, string imagefilename)
{
if (data.Contains(StandardDataFormats.StorageItems))
{
foreach (var file in await data.GetStorageItemsAsync())
{
AddAttachement(file as StorageFile);
}
}
else if (data.Contains(StandardDataFormats.Bitmap))
{
var bmpDPV = await data.GetBitmapAsync();
var bmpSTR = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(imagefilename + ".png", CreationCollisionOption.OpenIfExists);
using (var writeStream = (await bmpSTR.OpenStreamForWriteAsync()).AsRandomAccessStream())
using (var readStream = await bmpDPV.OpenReadAsync())
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(readStream.CloneStream());
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, writeStream);
encoder.SetSoftwareBitmap(await decoder.GetSoftwareBitmapAsync());
await encoder.FlushAsync();
AddAttachement(bmpSTR);
}
}
else if (data.Contains(StandardDataFormats.Text))
{
Editor.Text = await data.GetTextAsync();
}
else if (data.Contains(StandardDataFormats.WebLink))
{
Editor.Text = (await data.GetWebLinkAsync()).ToString();
}
else if (data.Contains(StandardDataFormats.ApplicationLink))
{
Editor.Text = (await data.GetApplicationLinkAsync()).ToString();
}
else if (data.Contains(StandardDataFormats.Html))
{
var converter = new Html2Markdown.Converter();
Editor.Text = converter.Convert(await data.GetHtmlFormatAsync());
}
}
static public async Task <NiconicoId?> CheckClipboard()
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.WebLink))
{
var uri = await dataPackageView.GetWebLinkAsync();
if (uri.OriginalString == prevContent)
{
return(null);
}
prevContent = uri.OriginalString;
return(NiconicoUrls.ExtractNicoContentId(uri));
}
else if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
if (prevContent == text)
{
return(null);
}
prevContent = text;
try
{
if (Uri.TryCreate(text, UriKind.Absolute, out var uri))
{
return(NiconicoUrls.ExtractNicoContentId(uri));
}
else
{
return(NiconicoId.TryCreate(text, out var id) ? id : null);
}
}
catch
{
}
}
return(null);
}
private async Task CheckClipboard()
{
using (var releaser = await _ClipboardProcessLock.LockAsync())
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.WebLink))
{
var uri = await dataPackageView.GetWebLinkAsync();
if (uri.OriginalString == prevContent)
{
return;
}
await ExtractNicoContentId_And_SubmitSuggestion(uri);
prevContent = uri.OriginalString;
}
else if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
if (prevContent == text)
{
return;
}
try
{
if (Uri.TryCreate(text, UriKind.Absolute, out var uri))
{
await ExtractNicoContentId_And_SubmitSuggestion(uri);
}
else
{
await ExtractNicoContentId_And_SubmitSuggestion(text);
}
}
catch
{
}
prevContent = text;
}
}
}
// クリップボードでは、ローミングされてきたら true になる
// 履歴では常に false
protected async Task SetDataAsync(DataPackageView content)
{
this.OriginalContent = content;
this.AvailableFormats = content.AvailableFormats?.ToList() ?? (new List <string>());
this.IsFromRoamingClipboard = content.Properties.IsFromRoamingClipboard;
// テキストデータ（該当するデータが複数あるときは、最後のもの）
this.TextHead = string.Empty; this.TextSize = 0;
if (content.Contains(StandardDataFormats.Html)) //"HTML Format"
{
this.TextHead = await content.GetHtmlFormatAsync();
}
if (content.Contains(StandardDataFormats.WebLink)) //"UniformResourceLocatorW"
{
this.TextHead = (await content.GetWebLinkAsync()).ToString();
}
if (content.Contains(StandardDataFormats.Text)) //"Text"
{
this.TextHead = await content.GetTextAsync();
}
this.TextSize = this.TextHead.Length * sizeof(char);
if (this.TextHead.Length > TextHeadMaxLength)
{
this.TextHead = $"{this.TextHead.Substring(0, TextHeadMaxLength)}(以下略)";
}
// ビットマップデータ
this.Bitmap = new BitmapImage(); this.BitmapSize = 0;
if (content.Contains(StandardDataFormats.Bitmap)) //"Bitmap"
{
RandomAccessStreamReference stRef = await content.GetBitmapAsync();
using (IRandomAccessStreamWithContentType stream = await stRef.OpenReadAsync())
{
this.Bitmap.SetSource(stream);
this.BitmapSize = stream.Size;
}
}
}
private async Task PasteAndAutoLinkUri(DataPackageView dataPackageView)
{
var linkRegex = new Regex(@"(?i)(http.+?(?=http))", RegexOptions.Compiled);
var uri = (await dataPackageView.GetWebLinkAsync()).AbsoluteUri;
//No idea why dataPackage can return a duplicate link
//so use regex to make sure we only take in one
var match = linkRegex.Match(uri);
string link;
if (match.Success)
{
link = match.Groups[1].ToString();
}
else
{
link = uri;
}
var html = String.Format(HyperLinkDialog.LINK_HTML, link, link);
await noteFieldView.HtmlEditor.InsertHtml(html);
}
private async void OnAddImageClicked(object sender, RoutedEventArgs e)
{
DataPackageView package = Clipboard.GetContent();
string imageUrl = string.Empty;
if (package.Contains(StandardDataFormats.Text))
{
imageUrl = await package.GetTextAsync();
}
else if (package.Contains(StandardDataFormats.ApplicationLink))
{
Uri imageUri = await package.GetWebLinkAsync();
imageUrl = imageUri.AbsoluteUri;
}
GraphServiceClient client = AuthenticationHelper.GetAuthenticatedClient();
var requestBuilder = client.Me.Activities.Request();
UserActivity activity = new UserActivity()
{
ActivationUrl = "blah",
ActivitySourceHost = "studiovn.life",
AppActivityId = Base64UrlEncoder.Encode(imageUrl),
VisualElements = new VisualInfo()
{
DisplayText = "Test"
},
ContentInfo = new JObject()
};
activity.VisualElements.DisplayText = "Test";
activity.ContentInfo["imageUrl"] = imageUrl;
var result = await requestBuilder.AddUserActivityAsync(activity);
this.viewModel.Images.Insert(0, new CloudImageViewModel(imageUrl));
}
private async Task ShowSharedWebLink(DataPackageView shareData)
{
DefaultViewModel["IsWebLinkShared"] = true;
DefaultViewModel["SharedWebLink"]
= await shareData.GetWebLinkAsync();
}
private static async Task <DataObject> ToDataObject(DataPackageView src, CancellationToken ct)
{
var dst = new DataObject();
// WPF has no format for URI therefore text is used for both
if (src.Contains(StandardDataFormats.Text))
{
dst.SetText(await src.GetTextAsync().AsTask(ct));
}
else
{
var uri = DataPackage.CombineUri(
src.Contains(StandardDataFormats.WebLink) ? (await src.GetWebLinkAsync().AsTask(ct)).ToString() : null,
src.Contains(StandardDataFormats.ApplicationLink) ? (await src.GetApplicationLinkAsync().AsTask(ct)).ToString() : null,
src.Contains(StandardDataFormats.Uri) ? (await src.GetUriAsync().AsTask(ct)).ToString() : null);
if (string.IsNullOrEmpty(uri) == false)
{
dst.SetText(uri);
}
}
if (src.Contains(StandardDataFormats.Html))
{
dst.SetData(DataFormats.Html, await src.GetHtmlFormatAsync().AsTask(ct));
}
if (src.Contains(StandardDataFormats.Rtf))
{
dst.SetData(DataFormats.Rtf, await src.GetRtfAsync().AsTask(ct));
}
if (src.Contains(StandardDataFormats.Bitmap))
{
var srcStreamRef = await src.GetBitmapAsync().AsTask(ct);
var srcStream = await srcStreamRef.OpenReadAsync().AsTask(ct);
// We copy the source stream in memory to avoid marshalling issue with async stream
// and to make sure to read it async as it built from a RandomAccessStream which might be remote.
using var tmp = new MemoryStream();
await srcStream.AsStreamForRead().CopyToAsync(tmp);
tmp.Position = 0;
var dstBitmap = new BitmapImage();
dstBitmap.BeginInit();
dstBitmap.CreateOptions = BitmapCreateOptions.None;
dstBitmap.CacheOption = BitmapCacheOption.OnLoad; // Required for the BitmapImage to internally cache the data (so we can dispose the tmp stream)
dstBitmap.StreamSource = tmp;
dstBitmap.EndInit();
dst.SetData(DataFormats.Bitmap, dstBitmap, false);
}
if (src.Contains(StandardDataFormats.StorageItems))
{
var files = await src.GetStorageItemsAsync().AsTask(ct);
var paths = new StringCollection();
foreach (var item in files)
{
paths.Add(item.Path);
}
dst.SetFileDropList(paths);
}
return(dst);
}
IAsyncOperation <Uri> IDataPackageViewResolver.GetWebLinkAsync(DataPackageView dataPackageView) => dataPackageView.GetWebLinkAsync();
public static async Task CopyTo(this DataPackageView view, IDictionary<string, object> values)
{
foreach (var format in view.AvailableFormats)
{
try
{
if (format == StandardDataFormats.Bitmap)
{
var value = await view.GetBitmapAsync();
values.Add(format, value);
}
else if (format == StandardDataFormats.Html)
{
var value = await view.GetHtmlFormatAsync();
values.Add(format, value);
if (!values.ContainsKey(StandardDataFormats.Text))
values.Add(StandardDataFormats.Text, value);
}
else if (format == StandardDataFormats.Rtf)
{
var value = await view.GetRtfAsync();
values.Add(format, value);
if (!values.ContainsKey(StandardDataFormats.Text))
values.Add(StandardDataFormats.Text, value);
}
else if (format == StandardDataFormats.StorageItems)
{
var value = await view.GetStorageItemsAsync();
var extensions = value.Select(f => "*" + Path.GetExtension(f.Name)).ToArray();
values.Add("extensions", extensions);
values.Add(format, value);
if (value.Count() == 1)
{
var file = value.OfType<StorageFile>().SingleOrDefault();
if(file != null && file.Attributes.HasFlag(FileAttributes.Temporary))
{
var copiedFile = await file.CopyAsync(
ApplicationData.Current.LocalFolder,
file.Name,
NameCollisionOption.ReplaceExisting);
values[format] = new[] { copiedFile };
}
if (!values.ContainsKey(StandardDataFormats.Bitmap))
{
var stream = RandomAccessStreamReference.CreateFromFile(file);
values.Add(StandardDataFormats.Bitmap, stream);
}
}
}
else if (format == StandardDataFormats.Text)
{
var value = await view.GetTextAsync();
values.Add(format, value);
}
else if (format == StandardDataFormats.ApplicationLink)
{
var value = await view.GetApplicationLinkAsync();
values.Add(format, value);
if (!values.ContainsKey(StandardDataFormats.Text))
values.Add(StandardDataFormats.Text, value.ToString());
}
else if (format == StandardDataFormats.WebLink)
{
var value = await view.GetWebLinkAsync();
values.Add(format, value);
if (!values.ContainsKey(StandardDataFormats.Text))
values.Add(StandardDataFormats.Text, value.ToString());
}
else if (ValidFormat(format))
{
var value = await view.GetDataAsync(format);
values.Add(format, value);
}
}
catch (SecurityException) { throw; }
catch
{
// Some formats are incompatible with WinRT and can cause it to throw unexpectedly.
// guard against it and give a best effort copy of the available formats that are supported.
}
}
}
private static async Task <ReceivedShareItem> FetchDataFromPackageViewAsync(DataPackageView packageView)
{
var rval = new ReceivedShareItem()
{
Title = packageView.Properties.Title,
Description = packageView.Properties.Description,
PackageFamilyName = packageView.Properties.PackageFamilyName,
ContentSourceWebLink = packageView.Properties.ContentSourceWebLink,
ContentSourceApplicationLink = packageView.Properties.ContentSourceApplicationLink,
LogoBackgroundColor = packageView.Properties.LogoBackgroundColor,
};
if (packageView.Properties.Square30x30Logo != null)
{
using (var logoStream = await packageView.Properties.Square30x30Logo.OpenReadAsync())
{
var logo = new MemoryStream();
await logoStream.AsStreamForRead().CopyToAsync(logo);
logo.Position = 0;
var str = Convert.ToBase64String(logo.ToArray());
//rval.Square30x30LogoBase64 = Convert.ToBase64String(logo.ToArray());
rval.Square30x30Logo = new Models.MemoryStreamBase64Item {
Base64String = str
};
}
}
if (packageView.Properties.Thumbnail != null)
{
using (var thumbnailStream = await packageView.Properties.Thumbnail.OpenReadAsync())
{
var thumbnail = new MemoryStream();
await thumbnailStream.AsStreamForRead().CopyToAsync(thumbnail);
thumbnail.Position = 0;
var str = Convert.ToBase64String(thumbnail.ToArray());
rval.Thumbnail = new Models.MemoryStreamBase64Item {
Base64String = str
};
}
}
if (packageView.Contains(StandardDataFormats.WebLink))
{
try
{
var link = new WebLinkShareItem
{
WebLink = await packageView.GetWebLinkAsync()
};
rval.AvialableShareItems.Add(link);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.ApplicationLink))
{
try
{
var sharedApplicationLink = new ApplicationLinkShareItem
{
ApplicationLink = await packageView.GetApplicationLinkAsync()
};
rval.AvialableShareItems.Add(sharedApplicationLink);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetApplicationLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.Text))
{
try
{
var sharedText = new TextShareItem {
Text = await packageView.GetTextAsync()
};
rval.AvialableShareItems.Add(sharedText);
rval.Text = await packageView.GetTextAsync();
//rval.GetValueContainer(x => x.Text)
// .GetNullObservable()
// .Subscribe(e => sharedText.Text = rval.Text)
// .DisposeWith(rval);
sharedText.GetValueContainer(x => x.Text)
.GetNullObservable()
.Subscribe(e => rval.Text = sharedText.Text)
.DisposeWith(rval);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetTextAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
if (packageView.Contains(StandardDataFormats.StorageItems))
{
try
{
var files = await packageView.GetStorageItemsAsync();
var sharedStorageItem = new FilesShareItem
{
StorageFiles = new ObservableCollection <FileItem>()
//StorageItems =
};
foreach (StorageFile sf in files)
{
var guidString = Guid.NewGuid().ToString();
StorageApplicationPermissions.FutureAccessList.AddOrReplace(guidString, sf, sf.Name);
var ts = await sf.GetScaledImageAsThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.VideosView);
var tmbs = new MemoryStream();
await ts.AsStreamForRead().CopyToAsync(tmbs);
var file = new FileItem
{
AccessToken = guidString,
ContentType = sf.ContentType,
FileName = sf.DisplayName,
PossiblePath = sf.Path,
Thumbnail = new Models.MemoryStreamBase64Item(tmbs.ToArray())
};
sharedStorageItem.StorageFiles.Add(file);
}
//StorageApplicationPermissions.FutureAccessList.AddOrReplace()
rval.AvialableShareItems.Add(sharedStorageItem);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetStorageItemsAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
//if (packageView.Contains(dataFormatName))
//{
// try
// {
// this.sharedCustomData = await packageView.GetTextAsync(dataFormatName);
// }
// catch (Exception ex)
// {
// //NotifyUserBackgroundThread("Failed GetTextAsync(" + dataFormatName + ") - " + ex.Message, NotifyType.ErrorMessage);
// }
//}
if (packageView.Contains(StandardDataFormats.Html))
{
var sharedHtmlFormatItem = new HtmlShareItem();
var sharedHtmlFormat = string.Empty;
try
{
sharedHtmlFormat = await packageView.GetHtmlFormatAsync();
//sharedHtmlFormatItem.HtmlFormat = sharedHtmlFormat;
sharedHtmlFormatItem.HtmlFragment = HtmlFormatHelper.GetStaticFragment(sharedHtmlFormat);
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetHtmlFormatAsync - " + ex.Message, NotifyType.ErrorMessage);
}
//try
//{
// var sharedResourceMap = await packageView.GetResourceMapAsync();
//}
//catch (Exception ex)
//{
// //NotifyUserBackgroundThread("Failed GetResourceMapAsync - " + ex.Message, NotifyType.ErrorMessage);
//}
//if (packageView.Contains(StandardDataFormats.WebLink))
//{
// try
// {
// sharedHtmlFormatItem.WebLink = await packageView.GetWebLinkAsync();
// }
// catch (Exception ex)
// {
// //NotifyUserBackgroundThread("Failed GetWebLinkAsync - " + ex.Message, NotifyType.ErrorMessage);
// }
//}
rval.AvialableShareItems.Add(sharedHtmlFormatItem);
}
if (packageView.Contains(StandardDataFormats.Bitmap))
{
try
{
var fi = await packageView.GetBitmapAsync();
using (var imgFileStream = await fi.OpenReadAsync())
{
var saveTargetStream = new InMemoryRandomAccessStream();
var bitmapSourceStream = imgFileStream;
await ServiceLocator
.Instance
.Resolve <IImageConvertService>()
.ConverterBitmapToTargetStreamAsync(bitmapSourceStream, saveTargetStream);
saveTargetStream.Seek(0);
var sr = saveTargetStream.GetInputStreamAt(0);
var source = sr.AsStreamForRead();
var ms = new MemoryStream();
await source.CopyToAsync(ms);
var sharedBitmapStreamRef = new DelayRenderedImageShareItem
{
SelectedImage = new Models.MemoryStreamBase64Item(ms.ToArray())
};
rval.AvialableShareItems.Add(sharedBitmapStreamRef);
}
}
catch (Exception ex)
{
//NotifyUserBackgroundThread("Failed GetBitmapAsync - " + ex.Message, NotifyType.ErrorMessage);
}
}
//foreach (var item in rval.AvialableShareItems)
//{
// //item.ContentSourceApplicationLink = rval.ContentSourceApplicationLink;
// //item.ContentSourceWebLink = rval.ContentSourceWebLink;
// //item.DefaultFailedDisplayText = rval.DefaultFailedDisplayText;
// //item.Description = rval.Description;
// //item.Title = rval.Title;
//}
return(rval);
}
private async void Init()
{
try
{
DataPackageView dataPackageView = this.ShareOperation.Data;
if (dataPackageView.Contains(StandardDataFormats.StorageItems))
{
IReadOnlyList <IStorageItem> readOnlyList = await dataPackageView.GetStorageItemsAsync();
if (readOnlyList == null || readOnlyList.Count == 0)
{
return;
}
IEnumerator <StorageFile> enumerator = Enumerable.OfType <StorageFile>(readOnlyList).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
StorageFile storageFile = enumerator.Current;
if (VKConstants.SupportedImageExtensions.Contains(storageFile.FileType.ToUpperInvariant()))
{
try
{
Stream var_3_1AB = (await storageFile.OpenReadAsync()).AsStreamForRead();
this.Photos.Add(var_3_1AB);
try
{
Stream var_5_233 = (await storageFile.GetThumbnailAsync(0)).AsStreamForRead();
this.PhotosPreviews.Add(var_5_233);
}
catch
{
this.PhotosPreviews.Add(null);
}
goto IL_2AC;
}
catch
{
goto IL_2AC;
}
//goto IL_262;
}
goto IL_262;
IL_2AC:
storageFile = null;
continue;
IL_262:
if (VKConstants.SupportedVideoExtensions.Contains(storageFile.FileType.ToLowerInvariant()))
{
this.Videos.Add(storageFile);
goto IL_2AC;
}
this.Documents.Add(storageFile);
goto IL_2AC;
}
}
finally
{
//int num;
if (enumerator != null)
{
enumerator.Dispose();
}
}
enumerator = null;
}
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string var_7_364 = await dataPackageView.GetTextAsync();
if (!string.IsNullOrWhiteSpace(var_7_364))
{
this.Message = var_7_364;
}
}
else if (dataPackageView.Contains(StandardDataFormats.WebLink))
{
try
{
object arg_409_0 = await dataPackageView.GetWebLinkAsync();
string var_9_415 = (arg_409_0 != null) ? arg_409_0.ToString() : null;
if (!string.IsNullOrWhiteSpace(var_9_415))
{
this.Message = var_9_415;
}
}
catch (UriFormatException)
{
}
}
dataPackageView = null;
}
catch
{
}
}
