private async void ShowSharedContent()
{
// Let Windows know that this app is starting to fetch data
_shareOperation.ReportStarted();
DefaultViewModel["ProcessingSharedData"] = true;
try
{
var formatOrdering = new AppSettings().OrderedFormats.ToList();
var shareData = _shareOperation.Data;
var preferredFormat = formatOrdering.FirstOrDefault(x => shareData.Contains(x.DataFormat));
if (preferredFormat.DataFormat == StandardDataFormats.Text)
{
await ShowSharedText(shareData);
}
//else if(preferredFormat.DataFormat == StandardDataFormats.Rtf)
//{
// // Not Implemented
// //ShowSharedRtf(shareData);
//}
else if (preferredFormat.DataFormat == StandardDataFormats.Html)
{
await ShowSharedHtml(shareData);
}
else if (preferredFormat.DataFormat == StandardDataFormats.Bitmap)
{
await ShowSharedBitmap(shareData);
}
// NOTE - StandardDataFormats.Uri is effectively Deprecated - see SetApplicationLink and/or SetWebLink instead
else if (preferredFormat.DataFormat == StandardDataFormats.ApplicationLink)
{
await ShowSharedAppLink(shareData);
}
else if (preferredFormat.DataFormat == StandardDataFormats.WebLink)
{
await ShowSharedWebLink(shareData);
}
else if (preferredFormat.DataFormat == StandardDataFormats.StorageItems)
{
await ShowSharedStorageItems(shareData);
}
else if (preferredFormat.DataFormat == AppSettings.CustomPersonSchemaName)
{
await ShowSharedCustomPerson(shareData);
}
}
catch (Exception e)
{
Debug.WriteLine("Share data retrieval error: " + e);
_shareOperation.ReportError("An error occurred while retrieving the shared data.");
}
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
var args = e.Parameter as ShareTargetActivatedEventArgs;
if (args == null)
{
return;
}
_shareOperation = args.ShareOperation;
if (_shareOperation.Data.Contains(
StandardDataFormats.Bitmap))
{
_bitmap = await _shareOperation.Data.GetBitmapAsync();
await ProcessBitmap();
}
else if (_shareOperation.Data.Contains(
StandardDataFormats.StorageItems))
{
_items = await _shareOperation.Data.GetStorageItemsAsync();
await ProcessStorageItems();
}
else
{
_shareOperation.ReportError(
"Image Helper was unable to find a valid bitmap.");
}
}
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);
}
}
public void Activate(ShareOperation shareOperation)
{
if (shareOperation == null)
{
throw new ArgumentNullException(nameof(shareOperation));
}
string title = null;
string description = null;
try
{
_shareOperation = shareOperation;
title = _shareOperation.Data.Properties.Title;
description = _shareOperation.Data.Properties.Description;
foreach (var format in _shareOperation.Data.AvailableFormats)
{
_shareFormats.Add(format);
}
Title = title;
Description = description;
}
catch (Exception ex)
{
_shareOperation.ReportError(ex.Message);
}
}
protected override void WireMessages()
{
Messenger.Default.Register <NotificationMessage>(this, m =>
{
if (m.Notification.Equals(Constants.Messages.ReaderViewLeftMsg))
{
ShowFinishedScreen = false;
if (_readerTimer != null && _readerTimer.IsEnabled)
{
_readerTimer.Stop();
}
var wordsRead = SelectedIndex * _settingsService.WordsAtATime;
var articleNotFinished = wordsRead < SelectedItem.WordCount;
if (articleNotFinished)
{
_roamingSettings.Set(SelectedItem.InternalId, wordsRead);
}
else
{
_roamingSettings.Remove(SelectedItem.InternalId);
}
SaveInProgressItems(wordsRead, !articleNotFinished);
}
});
Messenger.Default.Register <ShareMessage>(this, async m =>
{
_shareOperation = (ShareOperation)m.Sender;
if (_shareOperation.Data.Contains(StandardDataFormats.WebLink))
{
var url = await _shareOperation.Data.GetWebLinkAsync();
var message = new UriSchemeMessage(url.ToString(), true, SchemeType.Read);
await SaveItemFromExternal(message, async() =>
{
var title = _loader.GetString("ShareErrorTitle");
await _messageBox.ShowAsync(_loader.GetString("ShareErrorText"), title, new List <string> {
_loader.GetString("MessageBoxOk")
});
_shareOperation.ReportError(title);
});
}
else
{
_shareOperation.ReportCompleted();
}
});
Messenger.Default.Register <UriSchemeMessage>(this, async m =>
{
if (m.SchemeType != SchemeType.Read)
{
return;
}
await SaveItemFromExternal(m);
});
}
public void Copy()
{
try
{
if (_share.Data.Properties.ApplicationName != Constants.ApplicationName)
{
_share.ReportSubmittedBackgroundTask();
var content = new DataPackage();
_values.CopyTo(content);
Windows.ApplicationModel.DataTransfer.Clipboard.SetContent(content);
Windows.ApplicationModel.DataTransfer.Clipboard.Flush();
Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += OnClipboardContentChanged;
_share.DismissUI();
}
else
{
_share.ReportCompleted();
}
}
catch (Exception ex)
{
_share.ReportError(ex.Message);
}
}
public async Task Share()
{
Sharing = true;
ShareOperation.ReportStarted();
var multa = new CriarMultaNova
{
Descricao = dadosDaMulta.Descricao,
Placa = dadosDaMulta.Placa,
VideoUrl = dadosDaMulta.VideoUrl
};
multa.SetaDataOcorrencia(dadosDaMulta.DataOcorrencia);
try
{
MultadoComSucesso = await talao.MultarAsync(multa, fileInfo);
if (MultadoComSucesso)
{
Sharing = false;
ShareOperation.ReportCompleted();
}
else
{
ShareOperation.ReportError("Não foi possível multar, favor tentar mais tarde.");
}
}
catch (Exception ex)
{
ShareOperation.ReportError("Não foi possível multar, ocorreu um erro, favor tentar mais tarde.\nErro:" + ex.Message);
}
}
private void OnClipboardContentChanged(object sender, object e)
{
if (_share != null)
{
try
{
_share.ReportCompleted();
_share = null;
}
catch (Exception ex)
{
Debug.WriteLine(ex);
_share.ReportError(ex.ToString());
}
}
}
private async void sendButton_Click(object sender, RoutedEventArgs e)
{
try
{
if (channelsBox.SelectedItem is DiscordChannel channel)
{
if (_file != null)
{
overlay.Visibility = Visibility.Visible;
ring.Value = 0;
subtext.Opacity = 1;
var progress = new Progress <double?>(p => ring.Value = p ?? 0d);
var stream = await _file.OpenReadAsync();
var dictionary = new Dictionary <string, IInputStream>()
{
[_file.Name] = stream
};
await Tools.SendFilesWithProgressAsync(channel, captionText.Text, null, null, dictionary, progress);
}
else if (!string.IsNullOrWhiteSpace(captionText.Text))
{
await channel.SendMessageAsync(captionText.Text);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex);
await UIUtilities.ShowErrorDialogAsync("Sending failed!", ex.Message);
_shareOperation.ReportError(ex.Message);
return;
}
_shareOperation.ReportCompleted();
//_shareOperation.DismissUI();
}
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.");
}
}
}
public async Task OnShareTargetActivated(ShareOperation shareOperation)
{
this.shareOperation = shareOperation;
if (shareOperation.Data.Contains(StandardDataFormats.WebLink))
{
// https://www.microsoft.com/store/productId/9NNDJTDMH874
Uri webLink = await shareOperation.Data.GetWebLinkAsync();
if (!webLink.ToString().Contains("www.microsoft.com/store"))
{
Analytics.TrackEvent("Wrong share link");
shareOperation.ReportError("Data doesn't contain link to Microsoft Store.");
return;
}
string appId = webLink.ToString().Split('/').LastOrDefault();
var database = new Database();
var list = await database.GetAll();
if (list.Any(e => e.AppId == appId))
{
IsAppOnWishlist = true;
IsNewApp = false;
}
await CoreApplication.GetCurrentView().Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
AppName = shareOperation.Data.Properties.Title;
AppInfo = new ApplicationInfo()
{
AppId = appId,
AppName = AppName,
IsInstalledClicked = false,
};
});
}
}
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 ReportErrorButton_Click(object sender, RoutedEventArgs e)
{
m_shareOperation.ReportError(ReportError.Text);
}
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();
}