Beispiel #1
0
        private SupportedArchitectureType DecideInstallArchitecture(SupportedArchitectureType appSupportedArchitecture, SupportedArchitectureType desirableArchitecture)
        {
            var architectureOrder = new SupportedArchitectureType[]
            {
                SupportedArchitectureType.Arm64,
                SupportedArchitectureType.Arm,
                SupportedArchitectureType.X64,
                SupportedArchitectureType.X86
            };

            foreach (var architecture in architectureOrder)
            {
                if (appSupportedArchitecture.HasFlag(architecture) && desirableArchitecture.HasFlag(architecture))
                {
                    return(architecture);
                }
            }
            return(SupportedArchitectureType.None);
        }
Beispiel #2
0
        public async Task <(Application app, DownloadErrorType error)> Download(string appName, string version, SupportedArchitectureType desirableArchitecture, bool useCache = true)
        {
            try
            {
                Application application;

                // Application の情報を取得
                {
                    CloudTable table = tableClient.GetTableReference(PackageContainerName);

                    TableOperation retrieveOperation = TableOperation.Retrieve <AppPackageEntity>(appName, version);

                    // Execute the retrieve operation.
                    TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation);

                    // Print the phone number of the result.
                    if (retrievedResult.Result == null)
                    {
                        return(null, DownloadErrorType.UnknownError);
                    }
                    var appPackageEntity = (AppPackageEntity)retrievedResult.Result;

                    application = appPackageEntity.ConvertToApplication();
                }

                // app package をダウンロード
                var localFolder = localCacheFolder;
                var appPackage  = await DownloadBrob(localFolder, application.AppPackageId, useCache);

                if (appPackage == null)
                {
                    return(null, DownloadErrorType.NetworkError);
                }
                else
                {
                    application.AppPackage = appPackage;
                }

                // インストールするアプリのアーキテクチャタイプを決定
                var appSupportedArchitecture = application.SupportedArchitecture;
                SupportedArchitectureType installArchitecture =
                    DecideInstallArchitecture(appSupportedArchitecture, desirableArchitecture);

                if (installArchitecture == SupportedArchitectureType.None)
                {
                    return(null, DownloadErrorType.NotSupportedArchitecture);
                }

                application.Dependencies = new List <StorageFile>();
                foreach (var depId in application.DependencyIds)
                {
                    // 指定されたアーキテクチャの依存ファイルのみをダウンロード
                    var pattern = @"^.+_(\w+)_([\w\.]+)$";
                    var match   = Regex.Match(depId, pattern);

                    if (!match.Success)
                    {
                        continue;
                    }

                    var architectureString = match.Groups[1].Value;

                    var depArchitecture = SupportedArchitectureHelper.StringToSupportedArchitectureType(architectureString);
                    if (depArchitecture != installArchitecture)
                    {
                        continue;
                    }

                    var dep = await DownloadBrob(localFolder, depId, useCache);

                    if (dep == null)
                    {
                        return(null, DownloadErrorType.NetworkError);
                    }
                    else
                    {
                        application.Dependencies.Add(dep);
                    }
                }
                return(application, DownloadErrorType.NoError);
            }
            catch (Exception e)
            {
                return(null, DownloadErrorType.NetworkError);
            }
        }
Beispiel #3
0
 public Task <(Application app, DownloadErrorType error)> Download(string appName, string version, SupportedArchitectureType architecture, bool useCache = true)
 {
     throw new NotImplementedException();
 }