Fatal编程技术网
  • uwp/
  • UWP AppService发送取消系统策略

UWP AppService发送取消系统策略

uwp

UWP AppService发送取消系统策略,uwp,Uwp,在过去的3天里，我一直在尝试远程创建和使用Windows10UWP应用服务。当AppService在一台笔记本电脑上运行，而客户端在另一台笔记本电脑上运行（台式机到台式机）时，我就可以实现这一切。但是，当我在手机上安装客户端时，IBackgroundTaskInstance会取消，原因是：SystemPolicy。 我不知道为什么在手机到桌面的场景中它不起作用。 有人知道从哪里开始找吗 下面是我的服务课 using Newtonsoft.Json; using SharedObjects; us

在过去的3天里，我一直在尝试远程创建和使用Windows10UWP应用服务。当AppService在一台笔记本电脑上运行，而客户端在另一台笔记本电脑上运行（台式机到台式机）时，我就可以实现这一切。但是，当我在手机上安装客户端时，IBackgroundTaskInstance会取消，原因是：SystemPolicy。 我不知道为什么在手机到桌面的场景中它不起作用。 有人知道从哪里开始找吗

下面是我的服务课

using Newtonsoft.Json;
using SharedObjects;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Threading.Tasks;
using Windows.ApplicationModel;
using Windows.ApplicationModel.AppService;
using Windows.ApplicationModel.Background;
using Windows.ApplicationModel.Core;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Management.Deployment;
using Windows.Storage.Streams;

namespace AppStarterService
{
    public sealed class AppStarterTask : IBackgroundTask
    {
        BackgroundTaskDeferral serviceDeferral;
        AppServiceConnection connection;

        public void Run(IBackgroundTaskInstance taskInstance)
        {
            try
            {
                serviceDeferral = taskInstance.GetDeferral();
                taskInstance.Canceled += OnTaskCanceled;
                var details = taskInstance.TriggerDetails as AppServiceTriggerDetails;
                if (details.Name == "com.poctools.appstarter")
                {
                    connection = details.AppServiceConnection;
                    connection.RequestReceived += OnRequestReceived;
                    connection.ServiceClosed += Connection_ServiceClosed;
                }
                else
                {
                    serviceDeferral.Complete();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
                throw;
            }
        }

        async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
        {
            var messageDeferral = args.GetDeferral();
            try
            {
                var input = args.Request.Message;
                var packageList = await GetPackageListInfo();
                var json = JsonConvert.SerializeObject(packageList, Formatting.None);
                var result = new ValueSet();
                result.Add("result", json);
                Debug.WriteLine(json);
                var response = await args.Request.SendResponseAsync(result); //returns Success, even on the phone-to-desktop scenario
                Debug.WriteLine($"Send result: {response}");
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            finally
            {
                messageDeferral.Complete();
            }
        }

        private void Connection_ServiceClosed(AppServiceConnection sender, AppServiceClosedEventArgs args)
        {
            Debug.WriteLine($"Service closed: {args.Status}");
        }

        private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
        {
            Debug.WriteLine($"Task cancelled: {reason}");
            if (serviceDeferral != null)
            {
                serviceDeferral.Complete();
                serviceDeferral = null;
            }

            if (connection != null)
            {
                connection.Dispose();
                connection = null;
            }
        }



        private async Task<List<PackageInfo>> GetPackageListInfo()
        {
            try
            {
                List<PackageInfo> PackageInfoList = new List<PackageInfo>();

                PackageManager packageManager = new PackageManager();
                var Packages = packageManager.FindPackagesForUser("");

                foreach (var package in Packages.Where(p => p.SignatureKind == PackageSignatureKind.Store && !p.IsFramework))
                {
                    IReadOnlyList<AppListEntry> entryList = await package.GetAppListEntriesAsync();
                    if (entryList != null)
                    {
                        foreach (var entry in entryList)
                        {
                            if (entry != null)
                            {
                                Debug.WriteLine(entry.DisplayInfo.DisplayName);
                                var name = entry.DisplayInfo.DisplayName;
                                RandomAccessStreamReference stream = entry.DisplayInfo.GetLogo(new Size(150, 150));
                                if (stream != null)
                                {
                                    var streamContent = await stream.OpenReadAsync();
                                    if (streamContent != null)
                                    {
                                        byte[] buffer = new byte[streamContent.Size];
                                        await streamContent.ReadAsync(buffer.AsBuffer(), (uint)streamContent.Size, InputStreamOptions.None);
                                        string logo = Convert.ToBase64String(buffer);
                                        PackageInfoList.Add(new PackageInfo(name, package.Id.FamilyName, logo));
                                    }
                                }
                            }
                        }
                    }
                    Debug.WriteLine($"{package.Id.Name} - {package.SignatureKind}");
                }
                return PackageInfoList;
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
                throw;
            }
        }

    }
}

使用Newtonsoft.Json；
使用共享对象；
使用制度；
使用System.Collections.Generic；
使用系统诊断；
使用System.Linq；
使用System.Runtime.InteropServices.WindowsRuntime；
使用System.Threading.Tasks；
使用Windows.ApplicationModel；
使用Windows.ApplicationModel.AppService；
使用Windows.ApplicationModel.Background；
使用Windows.ApplicationModel.Core；
使用Windows基金会；
使用Windows。
使用Windows.Management.Deployment；
使用Windows.Storage.Streams；
命名空间AppStarter服务
{
公共密封类AppStarterTask:IBackgroundTask
{
背景任务延迟服务延迟；
AppServiceConnection连接；
公共无效运行（IBackgroundTaskInstance taskInstance）
{
尝试
{
serviceDeferral=taskInstance.GetDeferral（）；
taskInstance.Cancelled+=ontaskCancelled；
var details=taskInstance.TriggerDetails作为AppServiceTriggerDetails；
if（details.Name==“com.poctools.appstarter”）
{
connection=details.AppServiceConnection；
connection.RequestReceived+=OnRequestReceived；
connection.ServiceClosed+=连接\u ServiceClosed；
}
其他的
{
serviceDeleral.Complete（）；
}
}
捕获（例外情况除外）
{
Debug.WriteLine（例如消息）；
投掷；
}
}
async void OnRequestReceived（AppServiceConnection发送方，AppServiceRequestReceivedEventArgs参数）
{
var messageDeferral=args.GetDeferral（）；
尝试
{
var输入=args.Request.Message；
var packageList=await GetPackageListInfo（）；
var json=JsonConvert.SerializeObject（packageList，Formatting.None）；
var结果=新值集（）；
添加（“result”，json）；
WriteLine（json）；
var response=await args.Request.SendResponseAsync（result）；//返回成功，即使在电话到桌面的场景中也是如此
WriteLine（$“发送结果：{response}”）；
}
捕获（例外情况除外）
{
Debug.WriteLine（例如消息）；
}
最后
{
messagedeleral.Complete（）；
}
}
私有无效连接\u ServiceClosed（AppServiceConnection发送方，AppServiceClosedEventArgs参数）
{
WriteLine（$“服务已关闭：{args.Status}”）；
}
私有无效OnTaskCanceled（IBackgroundTaskInstance发件人，BackgroundTaskCancellationReason）
{
Debug.WriteLine（$“任务已取消：{reason}”）；
if（serviceDeleral！=null）
{
serviceDeleral.Complete（）；
ServiceDeleral=null；
}
if（连接！=null）
{
connection.Dispose（）；
连接=空；
}
}
专用异步任务GetPackageListInfo（）
{
尝试
{
列表包信息列表=新列表（）；
PackageManager PackageManager=新的PackageManager（）；
var Packages=packageManager.findpackagesfourser（“”）；
foreach（Packages.Where（p=>p.SignatureKind==PackageSignatureKind.Store&&！p.IsFramework）中的var包）
{
IReadOnlyList entryList=await package.GetAppListEntriesAsync（）；
if（entryList！=null）
{
foreach（entryList中的var条目）
{
if（条目！=null）
{
Debug.WriteLine（entry.DisplayInfo.DisplayName）；
var name=entry.DisplayInfo.DisplayName；
RandomAccessStreamReference stream=entry.DisplayInfo.GetLogo（新尺寸（150150））；
if（流！=null）
{
var streamContent=await stream.OpenReadAsync（）；
if（streamContent！=null）
{
byte[]buffer=新字节[streamContent.Size]；
等待streamContent.ReadAsync（buffer.AsBuffer（），（uint）streamContent.Size，InputStreamOptions.None）；
字符串logo=Convert.tobase64字符串（缓冲区）；
添加（新的PackageInfo（名称、package.Id.FamilyName、徽标））；
}
}
}
}
}
Debug.WriteLine（$“{package.Id.Name}-{package.SignatureKind}”）；
}
返回包信息列表；
}
捕获（例外情况除外）
{
Debug.WriteLine（例如消息）；
投掷；
}
}
}
}
主机和客户端之间发送的数据包大小有一个限制，显然我的手机只有几KB。 盖特盖利斯酒店 
    async void OnRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
    {
        var messageDeferral = args.GetDeferral();
        try
        {
            var inputs = args.Request.Message;
            if (Singleton.Instance.PackageList == null)
                Singleton.Instance.PackageList = await GetPackageListInfo();

            var itemsSend = inputs["items"] as string[]; //keep track of items already send
            inputs["items"] = null; //clear to keep response data small (it will be filled again when a new request comes in)
            var package = Singleton.Instance.PackageList.FirstOrDefault(p => !itemsSend.Contains(p.Id));
            if (package == null)
            {
                inputs["status"] = "stop"; //let the client know it's time to stop requesting
                inputs["package"] = null;
            }
            else
            {
                var json = JsonConvert.SerializeObject(package);
                inputs["package"] = json;
            }
            var response = await args.Request.SendResponseAsync(inputs);
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
        finally
        {
            messageDeferral?.Complete();
        }
    }

    async Task<byte[]> ResizeImage(byte[] imageData, int reqWidth, int reqHeight)
    {
        var memStream = new MemoryStream(imageData);

        using (IRandomAccessStream imageStream = memStream.AsRandomAccessStream())
        {
            //Get BitmapDecoder based on the original image
            var decoder = await BitmapDecoder.CreateAsync(imageStream);
            if (decoder.PixelHeight > reqHeight || decoder.PixelWidth > reqWidth)
            {
                //BitmapTransform defines a set of transformation to be applied to the original image (we're just interessted in scaling down)
                BitmapTransform transform = new BitmapTransform()
                {
                    ScaledHeight = (uint)reqHeight,
                    ScaledWidth = (uint)reqWidth,
                    InterpolationMode = BitmapInterpolationMode.Linear
                };

                PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
                    BitmapPixelFormat.Rgba8,
                    BitmapAlphaMode.Straight,
                    transform,
                    ExifOrientationMode.IgnoreExifOrientation,
                    ColorManagementMode.ColorManageToSRgb);

                var resizedStream = new InMemoryRandomAccessStream();
                BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, resizedStream);
                var pixels = pixelData.DetachPixelData();
                encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, (uint)reqWidth, (uint)reqHeight, 96, 96, pixels);
                await encoder.FlushAsync();
                var outBuffer = new byte[resizedStream.Size];
                await resizedStream.ReadAsync(outBuffer.AsBuffer(), (uint)resizedStream.Size, InputStreamOptions.None);

                return outBuffer;

            }
        }
        return imageData;
    }

    private async Task<List<PackageInfo>> GetPackageListInfo()
    {
        try
        {
            List<PackageInfo> PackageInfoList = new List<PackageInfo>();

            PackageManager packageManager = new PackageManager();
            IEnumerable<Package> Packages = packageManager.FindPackagesForUser("");

            foreach (var package in Packages.Where(p => p.SignatureKind == PackageSignatureKind.Store && !p.IsFramework))
            {
                IReadOnlyList<AppListEntry> entryList = await package.GetAppListEntriesAsync();
                if (entryList != null)
                {
                    foreach (var entry in entryList)
                    {
                        if (entry != null)
                        {
                            var name = entry.DisplayInfo.DisplayName;
                            RandomAccessStreamReference stream = entry.DisplayInfo.GetLogo(new Size(50, 50));
                            if (stream != null)
                            {
                                var streamContent = await stream.OpenReadAsync();
                                if (streamContent != null)
                                {
                                    byte[] buffer = new byte[streamContent.Size];
                                    await streamContent.ReadAsync(buffer.AsBuffer(), (uint)streamContent.Size, InputStreamOptions.None);
                                    if (streamContent.Size < 9000)
                                    {
                                        PackageInfoList.Add(new PackageInfo(package.Id.FullName, name, package.Id.FamilyName, buffer));
                                    }
                                    else
                                    {
                                        byte[] resizedBuffer = await ResizeImage(buffer, 50, 50);
                                        if (resizedBuffer.Length < 8192)//8kb
                                            PackageInfoList.Add(new PackageInfo(package.Id.FullName, name, package.Id.FamilyName, resizedBuffer));
                                    }
                                }
                            }
                        }
                    }
                }
                //Debug.WriteLine($"{package.Id.Name} - {package.SignatureKind}");
            }
            return PackageInfoList;
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
            throw;
        }
    }