private async Task ShowServiceErrorAsync(AppServiceResponseStatus status)
{
string error = null;
switch (status)
{
case AppServiceResponseStatus.Success:
error = "Service did not return the expected result";
break;
case AppServiceResponseStatus.Failure:
error = "Service failed to answer";
break;
case AppServiceResponseStatus.ResourceLimitsExceeded:
error = "Service exceeded the resource limits and was terminated";
break;
case AppServiceResponseStatus.Unknown:
error = "Unknown error";
break;
default:
break;
}
await new MessageDialog(error).ShowAsync();
}
//// ===========================================================================================================
//// Methods
//// ===========================================================================================================
public async Task <IServiceCommandResponse> SendCommandAsync(IServiceCommand command)
{
var valueSet = new ValueSet();
command.SerializeToValueSet(valueSet);
AppServiceResponse bridgeResponse = await _connection.SendMessageAsync(valueSet);
AppServiceResponseStatus status = bridgeResponse.Status;
IServiceCommandResponse response;
if (status == AppServiceResponseStatus.Success)
{
if (!ServiceCommandResponse.TryDeserializeFromValueSet(
bridgeResponse.Message,
out response,
out IServiceCommandResponse errorResponse))
{
response = errorResponse;
}
}
else
{
response = ServiceCommandResponse.CreateError(command.CommandName,
ServiceErrorInfo.InternalError($"AppServiceConnection failed with status '{status}'"));
}
return(response);
}
public static AppResponseStatus GetAppResponseStatus(this AppServiceResponseStatus status)
{
switch (status)
{
case AppServiceResponseStatus.Success:
return(AppResponseStatus.Success);
case AppServiceResponseStatus.Failure:
return(AppResponseStatus.Failure);
case AppServiceResponseStatus.ResourceLimitsExceeded:
return(AppResponseStatus.ResourceLimitsExceeded);
case AppServiceResponseStatus.Unknown:
return(AppResponseStatus.Unknown);
case AppServiceResponseStatus.RemoteSystemUnavailable:
return(AppResponseStatus.RemoteSystemUnavailable);
case AppServiceResponseStatus.MessageSizeTooLarge:
return(AppResponseStatus.MessageSizeTooLarge);
default:
throw new ArgumentOutOfRangeException(nameof(status), status, null);
}
}
/// <summary>
/// Receive messages from the other app
/// </summary>
/// <param name="sender">The connection the message is from</param>
/// <param name="args">The arguments for the message</param>
private async void RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
if (!IsValid())
{
_log.Information("AppConnection.RequestReceived: called before the connection is valid");
throw new InvalidOperationException("Message received before connection is opened");
}
var requestDefferal = args.GetDeferral();
try
{
_log.Information($"AppConnection.RequestReceived: received the following message: {ValueSetOut.ToString(args.Request.Message)}");
AppServiceResponseStatus status = AppServiceResponseStatus.Unknown;
if (MessageReceived != null)
{
AppMessage lc = AppMessage.FromValueSet(args.Request.Message);
AppMessage result = MessageReceived(lc);
_log.Information($"AppConnection.RequestRecieved: response: {result.ToString()}");
status = await args.Request.SendResponseAsync(result.ToValueSet());
}
_log.Information($"AppConnection.RequestReceived: Response to Request returned: {status.ToString()}");
}
finally
{
requestDefferal.Complete();
}
}
public async void Connection_OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
// read content
if (args.Request.Message.ContainsKey("content"))
{
object message = null;
args.Request.Message.TryGetValue("content", out message);
// if message is an int[]
if (message is int[])
{
// init field vars
int indexInArray = 0;
foreach (int trueorfalse in (int[])message)
{
// set bool state based on index
switch (indexInArray)
{
case 0:
test1On = Convert.ToBoolean(trueorfalse);
localSettings.Values["winFormTest1"] = (Convert.ToBoolean(trueorfalse)).ToString();
break;
case 1:
test2On = Convert.ToBoolean(trueorfalse);
localSettings.Values["winFormTest2"] = (Convert.ToBoolean(trueorfalse)).ToString();
break;
case 2:
test3On = Convert.ToBoolean(trueorfalse);
localSettings.Values["winFormTest3"] = (Convert.ToBoolean(trueorfalse)).ToString();
break;
default:
break;
}
indexInArray++;
}
await updateUI();
}
}
else if (args.Request.Message.ContainsKey("request"))
{
// send current settings as response
AppServiceResponseStatus responseStatus = await args.Request.SendResponseAsync(UpdateWin32());
}
}
private static string GenerateMessage(AppServiceResponseStatus status)
{
switch (status)
{
case AppServiceResponseStatus.Success:
throw new ArgumentException("Success sollte keine Exception auslösen.", nameof(status));
case AppServiceResponseStatus.Failure:
case AppServiceResponseStatus.ResourceLimitsExceeded:
case AppServiceResponseStatus.Unknown:
case AppServiceResponseStatus.RemoteSystemUnavailable:
case AppServiceResponseStatus.MessageSizeTooLarge:
return("");
default:
return("Unknown failure");
}
}
private async void SendPingMessage()
{
long id = ++this.messageId;
try
{
this.LogMessage("Sending AppServices message [" + id.ToString() + "]. Waiting for ping response");
var response = await this.appServiceConnection.SendMessageAsync(this.CreatePingMessage());
AppServiceResponseStatus status = response.Status;
if (status == AppServiceResponseStatus.Success)
{
this.LogMessage("Received successful AppService response to message [" + id.ToString() + "]");
Bundle bundle = response.Message;
string type = bundle.GetString("Type");
DateTime creationDate = DateTime.Parse(bundle.GetString("CreationDate"));
string targetId = bundle.GetString("TargetId");
DateTime nowDate = DateTime.Now;
int diff = nowDate.Subtract(creationDate).Milliseconds;
this.RunOnUiThread(() =>
{
SetPingText(this as Activity, diff.ToString());
});
}
else
{
this.LogMessage("Did not receive successful AppService response");
}
}
catch (ConnectedDevicesException e)
{
Console.WriteLine("Failed to send message using AppServices");
e.PrintStackTrace();
}
}
private async Task ShowServiceErrorAsync(AppServiceResponseStatus status)
{
string error = null;
switch (status)
{
case AppServiceResponseStatus.Success:
error = "Service did not return the expected result";
break;
case AppServiceResponseStatus.Failure:
error = "Service failed to answer";
break;
case AppServiceResponseStatus.ResourceLimitsExceeded:
error = "Service exceeded the resource limits and was terminated";
break;
case AppServiceResponseStatus.Unknown:
error = "Unknown error";
break;
default:
break;
}
await new MessageDialog(error).ShowAsync();
}
private async void SendPingMessage()
{
Bundle message = new Bundle();
message.PutString("Type", "ping");
message.PutString("CreationDate", DateTime.Now.ToString(CultureInfo.InvariantCulture));
message.PutString("TargetId", this.id);
try
{
var response = await this.appServiceClientConnection.SendMessageAsync(message);
AppServiceResponseStatus status = response.Status;
if (status == AppServiceResponseStatus.Success)
{
Bundle bundle = response.Message;
string type = bundle.GetString("Type");
DateTime creationDate = DateTime.Parse(bundle.GetString("CreationDate"));
string targetId = bundle.GetString("TargetId");
DateTime nowDate = DateTime.Now;
int diff = nowDate.Subtract(creationDate).Milliseconds;
this.RunOnUiThread(() =>
{
SetPingText(this as Activity, diff.ToString());
});
}
}
catch (ConnectedDevicesException e)
{
Console.WriteLine("Failed to send message using AppServices");
e.PrintStackTrace();
}
}
public static async void CutItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage()
{
RequestedOperation = DataPackageOperation.Move
};
ConcurrentBag <IStorageItem> items = new ConcurrentBag <IStorageItem>();
if (associatedInstance.SlimContentPage.IsItemSelected)
{
// First, reset DataGrid Rows that may be in "cut" command mode
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
var itemsCount = associatedInstance.SlimContentPage.SelectedItems.Count;
PostedStatusBanner banner = itemsCount > 50 ? App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
string.Format("StatusPreparingItemsDetails_Plural".GetLocalized(), itemsCount),
0,
ReturnResult.InProgress,
FileOperationType.Prepare, new CancellationTokenSource()) : null;
try
{
var dispatcherQueue = DispatcherQueue.GetForCurrentThread();
await associatedInstance.SlimContentPage.SelectedItems.ToList().ParallelForEachAsync(async listedItem =>
{
if (banner != null)
{
((IProgress <float>)banner.Progress).Report(items.Count / (float)itemsCount * 100);
}
// FTP don't support cut, fallback to copy
if (listedItem is not FtpItem)
{
_ = dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () =>
{
// Dim opacities accordingly
listedItem.Opacity = Constants.UI.DimItemOpacity;
});
}
if (listedItem is FtpItem ftpItem)
{
if (ftpItem.PrimaryItemAttribute is StorageItemTypes.File or StorageItemTypes.Folder)
{
items.Add(await ftpItem.ToStorageItem());
}
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.File || listedItem is ZipItem)
{
var result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
else
{
var result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
}, 10, banner?.CancellationToken ?? default);
}
catch (Exception ex)
{
if (ex.HResult == (int)FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Move }
});
if (status == AppServiceResponseStatus.Success)
{
banner?.Remove();
return;
}
}
}
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
banner?.Remove();
return;
}
banner?.Remove();
}
var onlyStandard = items.All(x => x is StorageFile || x is StorageFolder || x is SystemStorageFile || x is SystemStorageFolder);
if (onlyStandard)
{
items = new ConcurrentBag <IStorageItem>(await items.ToStandardStorageItemsAsync());
}
if (!items.Any())
{
return;
}
dataPackage.Properties.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
dataPackage.SetStorageItems(items, false);
try
{
Clipboard.SetContent(dataPackage);
}
catch
{
dataPackage = null;
}
}
internal ConnectionFailureException(AppServiceResponseStatus status) : base(GenerateMessage(status))
{
this.Status = status;
}
public static async Task CopyItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage()
{
RequestedOperation = DataPackageOperation.Copy
};
ConcurrentBag <IStorageItem> items = new ConcurrentBag <IStorageItem>();
if (associatedInstance.SlimContentPage.IsItemSelected)
{
var itemsCount = associatedInstance.SlimContentPage.SelectedItems.Count;
PostedStatusBanner banner = itemsCount > 50 ? App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
string.Format("StatusPreparingItemsDetails_Plural".GetLocalized(), itemsCount),
0,
ReturnResult.InProgress,
FileOperationType.Prepare, new CancellationTokenSource()) : null;
try
{
await associatedInstance.SlimContentPage.SelectedItems.ToList().ParallelForEach(async listedItem =>
{
if (banner != null)
{
((IProgress <float>)banner.Progress).Report(items.Count / (float)itemsCount * 100);
}
if (listedItem is FtpItem ftpItem)
{
if (listedItem.PrimaryItemAttribute == StorageItemTypes.File)
{
items.Add(await new FtpStorageFile(ftpItem).ToStorageFileAsync());
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.Folder)
{
items.Add(new FtpStorageFolder(ftpItem));
}
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.File || listedItem is ZipItem)
{
var result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
else
{
var result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
}, 10, banner?.CancellationToken ?? default);
}
catch (Exception ex)
{
if (ex.HResult == (int)FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Copy }
});
if (status == AppServiceResponseStatus.Success)
{
banner?.Remove();
return;
}
}
}
banner?.Remove();
return;
}
banner?.Remove();
}
var onlyStandard = items.All(x => x is StorageFile || x is StorageFolder || x is SystemStorageFile || x is SystemStorageFolder);
if (onlyStandard)
{
items = new ConcurrentBag <IStorageItem>(await items.ToStandardStorageItemsAsync());
}
if (!items.Any())
{
return;
}
dataPackage.Properties.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
dataPackage.SetStorageItems(items, false);
try
{
Clipboard.SetContent(dataPackage);
}
catch
{
dataPackage = null;
}
}
public void StatusReceived(AppServiceResponseStatus status)
{
this.onResponseReceived(status);
}
public static async void CutItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage
{
RequestedOperation = DataPackageOperation.Move
};
List <IStorageItem> items = new List <IStorageItem>();
FilesystemResult result = (FilesystemResult)false;
if (associatedInstance.SlimContentPage.IsItemSelected)
{
// First, reset DataGrid Rows that may be in "cut" command mode
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
foreach (ListedItem listedItem in associatedInstance.SlimContentPage.SelectedItems)
{
// Dim opacities accordingly
listedItem.Opacity = Constants.UI.DimItemOpacity;
if (listedItem.PrimaryItemAttribute == StorageItemTypes.File)
{
result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
break;
}
}
else
{
result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
break;
}
}
}
if (result.ErrorCode == FileSystemStatusCode.NotFound)
{
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
return;
}
else if (result.ErrorCode == FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
if (associatedInstance.ServiceConnection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await associatedInstance.ServiceConnection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Move }
});
if (status == AppServiceResponseStatus.Success)
{
return;
}
}
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
return;
}
}
if (!items.Any())
{
return;
}
dataPackage.SetStorageItems(items);
try
{
Clipboard.SetContent(dataPackage);
Clipboard.Flush();
}
catch
{
dataPackage = null;
}
}
public AppServiceTransmissionException(AppServiceResponseStatus responseStatus, string message, Exception innerException)
: base(message, innerException)
{
ResponseStatus = responseStatus;
}
public AppServiceTransmissionException(AppServiceResponseStatus responseStatus, string message)
: this(responseStatus, message, null)
{
}
public AppServiceTransmissionException(AppServiceResponseStatus responseStatus)
: this(responseStatus, string.Empty)
{
}
public static async void CutItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage()
{
RequestedOperation = DataPackageOperation.Move
};
ConcurrentBag <IStorageItem> items = new ConcurrentBag <IStorageItem>();
if (associatedInstance.SlimContentPage.IsItemSelected)
{
// First, reset DataGrid Rows that may be in "cut" command mode
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
try
{
await Task.WhenAll(associatedInstance.SlimContentPage.SelectedItems.ToList().Select(async listedItem =>
{
// FTP don't support cut, fallback to copy
if (listedItem is not FtpItem)
{
// Dim opacities accordingly
listedItem.Opacity = Constants.UI.DimItemOpacity;
}
if (listedItem is FtpItem ftpItem)
{
if (listedItem.PrimaryItemAttribute == StorageItemTypes.File)
{
items.Add(await new FtpStorageFile(ftpItem).ToStorageFileAsync());
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.Folder)
{
items.Add(new FtpStorageFolder(ftpItem));
}
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.File || listedItem is ZipItem)
{
var result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
else
{
var result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
}));
}
catch (Exception ex)
{
if (ex.HResult == (int)FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Move }
});
if (status == AppServiceResponseStatus.Success)
{
return;
}
}
}
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
return;
}
}
var onlyStandard = items.All(x => x is StorageFile || x is StorageFolder || x is SystemStorageFile || x is SystemStorageFolder);
if (onlyStandard)
{
items = new ConcurrentBag <IStorageItem>(await items.ToStandardStorageItemsAsync());
}
if (!items.Any())
{
return;
}
dataPackage.Properties.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
dataPackage.SetStorageItems(items, false);
try
{
Clipboard.SetContent(dataPackage);
}
catch
{
dataPackage = null;
}
}
public static RomeAppServiceResponseStatus ConvertToRomeAppServiceConnectionStatus(this AppServiceResponseStatus status)
{
if (status.Value == AppServiceResponseStatus.Failure.Value)
{
return(RomeAppServiceResponseStatus.Failure);
}
else if (status.Value == AppServiceResponseStatus.MessageSizeTooLarge.Value)
{
return(RomeAppServiceResponseStatus.MessageSizeTooLarge);
}
else if (status.Value == AppServiceResponseStatus.ResourceLimitsExceeded.Value)
{
return(RomeAppServiceResponseStatus.ResourceLimitsExceeded);
}
else if (status.Value == AppServiceResponseStatus.Success.Value)
{
return(RomeAppServiceResponseStatus.Success);
}
else if (status.Value == AppServiceResponseStatus.RemoteSystemUnavailable.Value)
{
return(RomeAppServiceResponseStatus.RemoteSystemUnavailable);
}
else if (status.Value == AppServiceResponseStatus.Unknown.Value)
{
return(RomeAppServiceResponseStatus.Unknown);
}
else
{
return(RomeAppServiceResponseStatus.Unknown);
}
}
