protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
_Operation = e.Parameter as ShareOperation;
Task.Factory.StartNew(async() =>
{
string text = null;
string html = null;
if (_Operation.Data.Contains(StandardDataFormats.Text))
{
text = await _Operation.Data.GetTextAsync();
}
if (_Operation.Data.Contains(StandardDataFormats.Html))
{
html = await _Operation.Data.GetHtmlFormatAsync();
}
_Operation.ReportDataRetrieved();
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
DoneBtn.IsEnabled = true;
txt1.Text = text ?? "";
txt2.Text = html ?? "";
});
});
}
public async void RetrieveData()
{
try
{
if (dataRetrieved)
{
await new MessageDialog("data already retrieved").ShowAsync();
}
_shareOperation.ReportStarted();
switch (SelectedFormat)
{
case "Text":
Text = await _shareOperation.Data.GetTextAsync();
break;
case "HTML Format":
Html = await _shareOperation.Data.GetHtmlFormatAsync();
break;
default:
break;
}
_shareOperation.ReportDataRetrieved();
dataRetrieved = true;
}
catch (Exception ex)
{
_shareOperation.ReportError(ex.Message);
}
}
private static async Task ProcessSharedImage(IRandomAccessStream stream, ShareOperation operation, string fileName)
{
var canvasData = await ImageWriterService.StreamToCanvasData(stream, fileName);
operation.ReportDataRetrieved();
NavigateToMain(canvasData);
}
public async void Initialize(ShareOperation share)
{
_share = share;
_share.ReportStarted();
await _share.Data.CopyTo(_values);
_share.ReportDataRetrieved();
}
public void StartShareTargetOperation(object shareOperation)
{
if (shareOperation is ShareOperation shareOperation1)
{
_shareOperation = shareOperation1;
_shareOperation.ReportDataRetrieved();
}
else
{
throw new ArgumentException($"Parameter {nameof(shareOperation)} must be of type {nameof(ShareOperation)}");
}
}
public async Task SetupShareDataAsync(ShareOperation share)
{
// store the share operation - we need to do this to hold a
// reference otherwise the sharing subsystem will assume
// that we've finished...
this.ShareOperation = share;
// get the properties out...
var data = share.Data;
var props = data.Properties;
this.Title = props.Title;
this.Description = props.Description;
// now the text...
if (data.Contains(StandardDataFormats.Text))
{
this.SharedText = await data.GetTextAsync();
}
// do we have an image? if so, load it...
if (data.Contains(StandardDataFormats.StorageItems) || data.Contains(StandardDataFormats.Bitmap))
{
IRandomAccessStreamReference reference = null;
// load the first one...
if (data.Contains(StandardDataFormats.StorageItems))
{
var file = (IStorageFile)(await data.GetStorageItemsAsync()).FirstOrDefault();
reference = RandomAccessStreamReference.CreateFromFile(file);
}
else
{
reference = await data.GetBitmapAsync();
}
// load it into an image...
var image = new BitmapImage();
using (var stream = await reference.OpenReadAsync())
image.SetSource(stream);
// set...
this.SharedImage = image;
this.ShowImage = true;
}
// tell the OS that we have the data...
share.ReportDataRetrieved();
}
protected override async void OnShareTargetActivated(ShareTargetActivatedEventArgs args)
{
ShareOperation = args.ShareOperation;
string type = await ExternalContentHelper.SetData(ShareOperation.Data);
if (type == "")
{
ShareOperation.ReportError("Unknown data type received.");
return;
}
ShareOperation.ReportDataRetrieved();
SendDataTemporaryStorage.IsSharingTarget = true;
Frame rootFrame = null;
LaunchRootFrameIfNecessary(ref rootFrame, false);
rootFrame.Navigate(typeof(MainPage), new ShareTargetDetails
{
Type = type,
});
}
protected override void OnShareTargetActivated(ShareTargetActivatedEventArgs args)
{
if (args.PreviousExecutionState == ApplicationExecutionState.NotRunning)
{
ShareOperation shareOperation = args.ShareOperation;
if (shareOperation.Data.Contains(StandardDataFormats.StorageItems))
{
shareOperation.ReportDataRetrieved();
Frame frame = new Frame();
frame.Navigate(typeof(ShareTargetPage), shareOperation);
Window.Current.Content = frame;
Window.Current.Activate();
}
else
{
shareOperation.ReportError("An error occured.");
}
}
else
{
// App is running
ShareOperation shareOperation = args.ShareOperation;
if (shareOperation.Data.Contains(StandardDataFormats.StorageItems))
{
shareOperation.ReportDataRetrieved();
var rootFrame = CreateRootFrame(args.PreviousExecutionState, "", typeof(ShareTargetPage));
rootFrame.Navigate(typeof(ShareTargetPage), shareOperation);
Window.Current.Activate();
}
else
{
shareOperation.ReportError("An error occured.");
}
}
}
protected override async void OnShareTargetActivated(ShareTargetActivatedEventArgs args)
{
ShareOperation shareOperation = args.ShareOperation;
var formats = shareOperation.Data.AvailableFormats.ToArray();
if (shareOperation.Data.Contains(StandardDataFormats.StorageItems))
{
shareOperation.ReportStarted();
var storageItems = await shareOperation.Data.GetStorageItemsAsync();
var firstFile = storageItems.First() as StorageFile;
string json = await FileToJson(firstFile);
shareOperation.ReportDataRetrieved();
LaunchMainUI(args);
ApplicationCenter.Receive(json);
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
try
{
// BUGBUG: this is messy
var items = new List <object> {
new { Name = "Direct Messages" }
};
items.AddRange(App.Discord.Guilds.Values.OrderBy(g => g.Name));
guildBox.ItemsSource = items;
channelsBox.ItemTemplateSelector = new ChannelTemplateSelector()
{
ServerChannelTemplate = (DataTemplate)App.Current.Resources["NoIndicatorChannelListTemplate"],
DirectMessageTemplate = (DataTemplate)App.Current.Resources["NoIndicatorDMChannelTemplate"]
};
//if (ApiInformation.IsApiContractPresent("Windows.Foundation.UniversalApiContract", 5))
//{
// var contact = _shareOperation.Contacts.FirstOrDefault();
// if (contact != null)
// {
// var id = await ContactListManager.TryGetChannelIdAsync(contact);
// if (id != 0)
// {
// guildBox.SelectedIndex = 0;
// channelsBox.SelectedItem = await App.Discord.CreateDmChannelAsync(id);
// target.Text = contact.DisplayName;
// destinationGrid.Visibility = Visibility.Collapsed;
// }
// }
//}
_shareOperation.ReportStarted();
var data = _shareOperation.Data;
if (data.AvailableFormats.Contains(StandardDataFormats.StorageItems))
{
_file = (await data.GetStorageItemsAsync()).FirstOrDefault() as StorageFile;
var img = new BitmapImage();
thumbnailImage.Source = img;
await img.SetSourceAsync(await _file.GetThumbnailAsync(ThumbnailMode.SingleItem));
return;
}
else if (data.AvailableFormats.Contains(StandardDataFormats.Bitmap))
{
// do shit
_file = await Tools.GetImageFileFromDataPackage(data);
var img = new BitmapImage();
thumbnailImage.Source = img;
await img.SetSourceAsync(await _file.GetThumbnailAsync(ThumbnailMode.PicturesView));
return;
}
else
{
thumbnailImage.Visibility = Visibility.Collapsed;
captionText.PlaceholderText = "Type a message!";
}
if (data.AvailableFormats.Contains(StandardDataFormats.Text))
{
var text = await data.GetTextAsync();
captionText.Text += text;
}
if (data.AvailableFormats.Contains(StandardDataFormats.WebLink))
{
var text = await data.GetWebLinkAsync();
captionText.Text += text;
}
}
finally
{
_shareOperation.ReportDataRetrieved();
this.FindParent <MainPage>().HideConnectingOverlay();
if (_file != null)
{
var maxSize = (ulong)(App.Discord.CurrentUser.UploadLimit());
var props = await _file.GetBasicPropertiesAsync();
if (props.Size >= maxSize)
{
await UIUtilities.ShowErrorDialogAsync("This file is too big!", $"We're gonna need something under {Tools.ToFileSizeString(maxSize)} please!");
Window.Current.Close();
}
}
}
}
private void ShowSharedContent()
{
// Let Windows know that this app is starting to fetch data
_shareOperation.ReportStarted();
DefaultViewModel["ProcessingSharedData"] = true;
try
{
var shareData = _shareOperation.Data;
var showContentTaskList = new List <Task>();
if (shareData.Contains(StandardDataFormats.Text))
{
var task = ShowSharedText(shareData);
showContentTaskList.Add(task);
}
if (shareData.Contains(StandardDataFormats.Rtf))
{
// Not Implemented
//ShowSharedRtf(shareData);
}
if (shareData.Contains(StandardDataFormats.Html))
{
var task = ShowSharedHtml(shareData);
showContentTaskList.Add(task);
}
if (shareData.Contains(StandardDataFormats.Bitmap))
{
var task = ShowSharedBitmap(shareData);
showContentTaskList.Add(task);
}
// NOTE - SetUri is effectively Deprecated - see SetApplicationLink and/or SetWebLink instead
if (shareData.Contains(StandardDataFormats.ApplicationLink))
{
var task = ShowSharedAppLink(shareData);
showContentTaskList.Add(task);
}
if (shareData.Contains(StandardDataFormats.WebLink))
{
var task = ShowSharedWebLink(shareData);
showContentTaskList.Add(task);
}
if (shareData.Contains(StandardDataFormats.StorageItems))
{
var task = ShowSharedStorageItems(shareData);
showContentTaskList.Add(task);
}
if (shareData.Contains(AppSettings.CustomPersonSchemaName))
{
var task = ShowSharedCustomPerson(shareData);
showContentTaskList.Add(task);
}
// Admittedly a bit unusual to be doing this "task stuff"; most apps will just bring in their "favorite" data format
// and signal Retrieved/Complete right there...since this is more of a "sampler", the Task API is used to wait for
// all of the retrives to finish and then signal that the data txfer is complete, and update the UI elements accordingly.
Task.WhenAll(showContentTaskList).ContinueWith(task =>
{
_shareOperation.ReportDataRetrieved();
DefaultViewModel["ProcessingSharedData"] = false;
});
}
catch (Exception e)
{
Debug.WriteLine("Share data retrieval error: " + e);
_shareOperation.ReportError("An error occurred while retrieving the shared data.");
}
}
private void ReportDataRetrieved_Click(object sender, RoutedEventArgs e)
{
m_shareOperation.ReportDataRetrieved();
rootPage.NotifyUser("Data retrieved...", NotifyType.StatusMessage);
}
public async Task ActiveSync(ShareOperation shareOperation)
{
_shareOperation = shareOperation;
shareOperation.ReportStarted();
try
{
var dataPackageView = shareOperation.Data;
RequestTitle = _shareOperation.Data.Properties.Title;
RequestDescription = _shareOperation.Data.Properties.Description;
if (dataPackageView.IsTextMessage())
{
IsTextRequest = true;
TextShareValue = await dataPackageView.GetTextAsync();
}
else if (dataPackageView.IsUrlMessage())
{
IsUrlRequest = true;
var foundUri = await dataPackageView.GetUriAsync();
UrlShareValue = foundUri.AbsoluteUri;
}
else if (dataPackageView.IsImageMessage())
{
IsImageRequest = true;
RandomAccessStreamReference imageReceived = await dataPackageView.GetBitmapAsync();
var imageStream = await imageReceived.OpenReadAsync();
ImageShareValue = new BitmapImage();
ImageShareValue.SetSource(imageStream);
OnPropertyChanged("ImageShareValue");
}
else if (dataPackageView.IsStorageItemsMessage())
{
IsStorageRequest = true;
var storageItems = await dataPackageView.GetStorageItemsAsync();
if (storageItems.Any())
{
var storageItem = storageItems.First();
if (storageItem.IsOfType(StorageItemTypes.File))
{
StorageFileName = storageItem.Name;
var thumbnail = dataPackageView.Properties.Thumbnail;
var thumbnailStream = await thumbnail.OpenReadAsync();
ImageShareValue = new BitmapImage();
ImageShareValue.SetSource(thumbnailStream);
}
}
}
}
catch (Exception e)
{
_shareOperation.ReportError(e.Message);
RequestDescription = e.Message;
}
_shareOperation.ReportDataRetrieved();
}