unity/textdecalURP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update libs

Browse Source
This commit is contained in:
Kirill Chikalin
2025-02-13 17:48:12 +03:00
parent e17e7c2786
commit 275dc598c7
816 changed files with 22479 additions and 10792 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/ASAnalytics.cs
View File

@@ -1,80 +0,0 @@
using System;
using UnityEditor;
using UnityEngine.Analytics;
namespace AssetStoreTools.Uploader.Data
{
internal static class ASAnalytics
{
private const int VersionId = 3;
private const int MaxEventsPerHour = 20;
private const int MaxNumberOfElements = 1000;
private const string VendorKey = "unity.assetStoreTools";
private const string EventName = "assetStoreTools";
static bool EnableAnalytics()
{
#if UNITY_2023_2_OR_NEWER
return true;
#else
var result = EditorAnalytics.RegisterEventWithLimit(EventName, MaxEventsPerHour, MaxNumberOfElements, VendorKey, VersionId);
return result == AnalyticsResult.Ok;
#endif
}
[System.Serializable]
public struct AnalyticsData
#if UNITY_2023_2_OR_NEWER
: IAnalytic.IData
#endif
{
public string ToolVersion;
public string PackageId;
public string Category;
public bool UsedValidator;
public string ValidatorResults;
public string UploadFinishedReason;
public double TimeTaken;
public long PackageSize;
public string Workflow;
public string EndpointUrl;
}
#if UNITY_2023_2_OR_NEWER
[AnalyticInfo(eventName: EventName, vendorKey: VendorKey, version: VersionId, maxEventsPerHour: MaxEventsPerHour, maxNumberOfElements: MaxNumberOfElements)]
private class AssetStoreToolsAnalytic : IAnalytic
{
private AnalyticsData _data;
public AssetStoreToolsAnalytic(AnalyticsData data)
{
_data = data;
}
public bool TryGatherData(out IAnalytic.IData data, out Exception error)
{
error = null;
data = _data;
return data != null;
}
}
#endif
public static void SendUploadingEvent(AnalyticsData data)
{
if (!EditorAnalytics.enabled)
return;
if (!EnableAnalytics())
return;
#if UNITY_2023_2_OR_NEWER
var analytic = new AssetStoreToolsAnalytic(data);
EditorAnalytics.SendAnalytic(analytic);
#else
EditorAnalytics.SendEventWithLimit(EventName, data, VersionId);
#endif
}
}
}

10
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/ASAnalytics.cs.meta
View File

@@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 1095145789a64767a6add837eea19786
timeCreated: 1658832954
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 11.4.4
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/ASAnalytics.cs
uploadId: 712972

8
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 771776e4d51c47945b3449d4de948c00
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

34
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackage.cs Normal file
View File

@@ -0,0 +1,34 @@
using System;
using UnityEngine;
using PackageModel = AssetStoreTools.Api.Models.Package;
namespace AssetStoreTools.Uploader.Data
{
internal interface IPackage
{
string PackageId { get; }
string VersionId { get; }
string Name { get; }
string Status { get; }
string Category { get; }
bool IsCompleteProject { get; }
string RootGuid { get; }
string RootPath { get; }
string ProjectPath { get; }
string Modified { get; }
string Size { get; }
bool IsDraft { get; }
Texture2D Icon { get; }
event Action OnUpdate;
event Action OnIconUpdate;
string FormattedSize();
string FormattedModified();
void UpdateData(PackageModel source);
void UpdateIcon(Texture2D texture);
PackageModel ToModel();
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackage.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: b92f2ed98d0b31a479aa2bfd95528fbd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackage.cs
uploadId: 724584

14
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackageContent.cs Normal file
View File

@@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
namespace AssetStoreTools.Uploader.Data
{
internal interface IPackageContent
{
event Action<IWorkflow> OnActiveWorkflowChanged;
IWorkflow GetActiveWorkflow();
List<IWorkflow> GetAvailableWorkflows();
void SetActiveWorkflow(IWorkflow workflow);
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackageContent.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 45ce41158c3174149b7056a30ac901db
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackageContent.cs
uploadId: 724584

17
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackageGroup.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
namespace AssetStoreTools.Uploader.Data
{
internal interface IPackageGroup
{
string Name { get; }
List<IPackage> Packages { get; }
event Action<List<IPackage>> OnPackagesSorted;
event Action<List<IPackage>> OnPackagesFiltered;
void Sort(PackageSorting sortingType);
void Filter(string filter);
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackageGroup.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: f683845071b8891498156d95a1a5c2dd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IPackageGroup.cs
uploadId: 724584

36
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IWorkflow.cs Normal file
View File

@@ -0,0 +1,36 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Exporter;
using AssetStoreTools.Validator.Data;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace AssetStoreTools.Uploader.Data
{
internal interface IWorkflow
{
string Name { get; }
string DisplayName { get; }
string PackageName { get; }
string PackageExtension { get; }
bool IsPathSet { get; }
event Action OnChanged;
event Action<UploadStatus?, float?> OnUploadStateChanged;
bool GenerateHighQualityPreviews { get; set; }
ValidationSettings LastValidationSettings { get; }
ValidationResult LastValidationResult { get; }
IEnumerable<string> GetAllPaths();
ValidationResult Validate();
Task<PackageExporterResult> ExportPackage(string outputPath);
Task<bool> ValidatePackageUploadedVersions();
Task<PackageUploadResponse> UploadPackage(string exportedPackagePath);
void AbortUpload();
void ResetUploadStatus();
Task RefreshPackage();
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IWorkflow.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 7a2f796eadafa774bae89cf3939611dd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IWorkflow.cs
uploadId: 724584

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IWorkflowServices.cs Normal file
View File

@@ -0,0 +1,18 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Uploader.Services.Analytics.Data;
using System;
using System.Threading.Tasks;
using UnityEngine.Analytics;
namespace AssetStoreTools.Uploader.Data
{
internal interface IWorkflowServices
{
Task<PackageUploadedUnityVersionDataResponse> GetPackageUploadedVersions(IPackage package, int timeoutMs);
Task<PackageUploadResponse> UploadPackage(IPackageUploader uploader, IProgress<float> progress);
void StopUploading(IPackageUploader uploader);
AnalyticsResult SendAnalytic(IAssetStoreAnalytic data);
Task<RefreshedPackageDataResponse> UpdatePackageData(IPackage package);
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IWorkflowServices.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 0ae017363fa41ff4d9926dc4a5852246
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/IWorkflowServices.cs
uploadId: 724584

253
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/WorkflowBase.cs Normal file
View File

@@ -0,0 +1,253 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Exporter;
using AssetStoreTools.Previews;
using AssetStoreTools.Previews.Data;
using AssetStoreTools.Previews.Generators;
using AssetStoreTools.Uploader.Services.Analytics.Data;
using AssetStoreTools.Utility;
using AssetStoreTools.Validator;
using AssetStoreTools.Validator.Data;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
namespace AssetStoreTools.Uploader.Data
{
internal abstract class WorkflowBase : IWorkflow
{
protected IPackage Package;
public abstract string Name { get; }
public abstract string DisplayName { get; }
public string PackageName => Package.Name;
public abstract string PackageExtension { get; }
public abstract bool IsPathSet { get; }
protected string LocalPackageGuid;
protected string LocalPackagePath;
protected string LocalProjectPath;
public bool GenerateHighQualityPreviews { get; set; }
public ValidationSettings LastValidationSettings { get; private set; }
public ValidationResult LastValidationResult { get; private set; }
private IWorkflowServices _services;
private IPackageUploader _activeUploader;
public abstract event Action OnChanged;
public event Action<UploadStatus?, float?> OnUploadStateChanged;
public WorkflowBase(IPackage package, IWorkflowServices services)
{
Package = package;
_services = services;
}
public abstract IEnumerable<string> GetAllPaths();
public abstract IValidator CreateValidator();
public ValidationResult Validate()
{
var validator = CreateValidator();
var result = CreateValidator().Validate();
LastValidationSettings = validator.Settings;
LastValidationResult = result;
return result;
}
protected IPreviewGenerator CreatePreviewGenerator(List<string> inputPaths)
{
PreviewGenerationSettings settings;
IPreviewGenerator generator;
// Filter out ProjectSettings
inputPaths = inputPaths.Where(x => x == "Assets" || x.StartsWith("Assets/") || x.StartsWith("Packages/")).ToList();
if (!GenerateHighQualityPreviews)
{
settings = new NativePreviewGenerationSettings()
{
InputPaths = inputPaths.ToArray(),
OverwriteExisting = false,
OutputPath = Constants.Previews.Native.DefaultOutputPath,
Format = Constants.Previews.Native.DefaultFormat,
PreviewFileNamingFormat = Constants.Previews.DefaultFileNameFormat,
WaitForPreviews = Constants.Previews.Native.DefaultWaitForPreviews,
ChunkedPreviewLoading = Constants.Previews.Native.DefaultChunkedPreviewLoading,
ChunkSize = Constants.Previews.Native.DefaultChunkSize
};
generator = new NativePreviewGenerator((NativePreviewGenerationSettings)settings);
}
else
{
settings = new CustomPreviewGenerationSettings()
{
InputPaths = inputPaths.ToArray(),
OverwriteExisting = false,
Width = Constants.Previews.Custom.DefaultWidth,
Height = Constants.Previews.Custom.DefaultHeight,
Depth = Constants.Previews.Custom.DefaultDepth,
NativeWidth = Constants.Previews.Custom.DefaultNativeWidth,
NativeHeight = Constants.Previews.Custom.DefaultNativeHeight,
OutputPath = Constants.Previews.Custom.DefaultOutputPath,
Format = Constants.Previews.Custom.DefaultFormat,
PreviewFileNamingFormat = Constants.Previews.DefaultFileNameFormat,
AudioSampleColor = Constants.Previews.Custom.DefaultAudioSampleColor,
AudioBackgroundColor = Constants.Previews.Custom.DefaultAudioBackgroundColor,
};
generator = new CustomPreviewGenerator((CustomPreviewGenerationSettings)settings);
}
return generator;
}
public abstract IPackageExporter CreateExporter(string outputPath);
public virtual async Task<PackageExporterResult> ExportPackage(string outputPath)
{
var exporter = CreateExporter(outputPath);
var result = await exporter.Export();
return result;
}
public async Task<bool> ValidatePackageUploadedVersions()
{
var unityVersionSupported = string.Compare(Application.unityVersion, Constants.Uploader.MinRequiredUnitySupportVersion, StringComparison.Ordinal) >= 0;
if (unityVersionSupported)
return true;
var response = await _services.GetPackageUploadedVersions(Package, 5000);
if (response.Cancelled || response.Success == false)
return true;
return response.UnityVersions.Any(x => string.Compare(x, Constants.Uploader.MinRequiredUnitySupportVersion, StringComparison.Ordinal) >= 0);
}
private bool ValidatePackageBeforeUpload(string packagePath, out string error)
{
error = string.Empty;
if (!File.Exists(packagePath))
{
error = $"File '{packagePath}' was not found.";
return false;
}
if (!ValidatePackageSize(packagePath, out error))
{
return false;
}
return true;
}
private bool ValidatePackageSize(string packagePath, out string error)
{
error = string.Empty;
long packageSize = new FileInfo(packagePath).Length;
long packageSizeLimit = Constants.Uploader.MaxPackageSizeBytes;
if (packageSize <= packageSizeLimit)
return true;
float packageSizeInGB = packageSize / (float)1073741824; // (1024 * 1024 * 1024)
float maxPackageSizeInGB = packageSizeLimit / (float)1073741824;
error = $"The size of your package ({packageSizeInGB:0.0} GB) exceeds the maximum allowed package size of {maxPackageSizeInGB:0} GB. " +
$"Please reduce the size of your package.";
return false;
}
public async Task<PackageUploadResponse> UploadPackage(string packagePath)
{
if (!ValidatePackageBeforeUpload(packagePath, out var error))
{
return new PackageUploadResponse() { Success = false, Status = UploadStatus.Fail, Exception = new Exception(error) };
}
_activeUploader = CreatePackageUploader(packagePath);
var progress = new Progress<float>();
var time = System.Diagnostics.Stopwatch.StartNew();
progress.ProgressChanged += ReportUploadProgress;
var response = await _services.UploadPackage(_activeUploader, progress);
progress.ProgressChanged -= ReportUploadProgress;
// Send analytics
time.Stop();
if (!response.Cancelled)
SendAnalytics(packagePath, response.Status, time.Elapsed.TotalSeconds);
OnUploadStateChanged?.Invoke(response.Status, null);
_activeUploader = null;
return response;
}
protected abstract IPackageUploader CreatePackageUploader(string exportedPackagePath);
private void ReportUploadProgress(object _, float value)
{
OnUploadStateChanged?.Invoke(null, value);
}
private void SendAnalytics(string packagePath, UploadStatus uploadStatus, double timeTakenSeconds)
{
try
{
var analytic = new PackageUploadAnalytic(
packageId: Package.PackageId,
category: Package.Category,
usedValidator: LastValidationResult != null,
validationSettings: LastValidationSettings,
validationResult: LastValidationResult,
uploadFinishedReason: uploadStatus,
timeTaken: timeTakenSeconds,
packageSize: new FileInfo(packagePath).Length,
workflow: Name
);
var result = _services.SendAnalytic(analytic);
}
catch (Exception e) { ASDebug.LogError($"Could not send analytics: {e}"); }
}
public void AbortUpload()
{
if (_activeUploader != null)
_services.StopUploading(_activeUploader);
_activeUploader = null;
}
public void ResetUploadStatus()
{
OnUploadStateChanged?.Invoke(UploadStatus.Default, 0f);
}
public async Task RefreshPackage()
{
var response = await _services.UpdatePackageData(Package);
if (!response.Success)
return;
Package.UpdateData(response.Package);
}
public abstract bool IsPathValid(string path, out string reason);
protected abstract void Serialize();
protected abstract void Deserialize();
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/WorkflowBase.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: d0e87ee17aa944c42b1c335abe19daaf
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Abstractions/WorkflowBase.cs
uploadId: 724584

329
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/AssetsWorkflow.cs Normal file
View File

@@ -0,0 +1,329 @@
using AssetStoreTools.Api;
using AssetStoreTools.Exporter;
using AssetStoreTools.Uploader.Data.Serialization;
using AssetStoreTools.Utility;
using AssetStoreTools.Validator;
using AssetStoreTools.Validator.Data;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using PackageInfo = UnityEditor.PackageManager.PackageInfo;
namespace AssetStoreTools.Uploader.Data
{
internal class AssetsWorkflow : WorkflowBase
{
public override string Name => "AssetsWorkflow";
public override string DisplayName => "From Assets Folder";
public override string PackageExtension => ".unitypackage";
public override bool IsPathSet => !string.IsNullOrEmpty(_mainExportPath);
public bool IsCompleteProject => Package.IsCompleteProject;
private AssetsWorkflowState _stateData;
private string _mainExportPath;
private bool _includeDependencies;
private List<PackageInfo> _dependencies;
private List<string> _specialFolders;
public override event Action OnChanged;
// Special folders that would not work if not placed directly in the 'Assets' folder
private readonly string[] _extraAssetFolderNames =
{
"Editor Default Resources", "Gizmos", "Plugins",
"StreamingAssets", "Standard Assets", "WebGLTemplates",
"ExternalDependencyManager", "XR"
};
public AssetsWorkflow(IPackage package, AssetsWorkflowState stateData, IWorkflowServices services)
: base(package, services)
{
_stateData = stateData;
Deserialize();
}
public string GetMainExportPath()
{
return _mainExportPath;
}
public void SetMainExportPath(string path, bool serialize)
{
_mainExportPath = path;
SetMetadata();
if (serialize)
Serialize();
}
private void SetMetadata()
{
LocalPackageGuid = AssetDatabase.AssetPathToGUID(_mainExportPath);
LocalPackagePath = _mainExportPath;
LocalProjectPath = _mainExportPath;
}
public bool GetIncludeDependencies()
{
return _includeDependencies;
}
public void SetIncludeDependencies(bool value, bool serialize)
{
_includeDependencies = value;
// Note: make sure that exporting does not fail when
// a serialized dependency that has been removed from a project is sent to exporter
if (serialize)
Serialize();
}
public List<PackageInfo> GetDependencies()
{
return _dependencies;
}
public void SetDependencies(IEnumerable<string> dependencies, bool serialize)
{
_dependencies.Clear();
foreach (var dependency in dependencies)
{
if (!PackageUtility.GetPackageByPackageName(dependency, out var package))
continue;
_dependencies.Add(package);
}
if (serialize)
Serialize();
}
public List<string> GetSpecialFolders()
{
return _specialFolders;
}
public void SetSpecialFolders(IEnumerable<string> specialFolders, bool serialize)
{
_specialFolders.Clear();
foreach (var folder in specialFolders)
{
_specialFolders.Add(folder);
}
if (serialize)
Serialize();
}
public override bool IsPathValid(string path, out string error)
{
error = string.Empty;
var pathIsFolder = Directory.Exists(path);
if (!pathIsFolder)
{
error = "Path must point to a valid folder";
return false;
}
var pathWithinAssetsFolder = path.StartsWith("Assets/") && path != "Assets/";
if (pathWithinAssetsFolder)
return true;
var pathIsAssetsFolder = path == "Assets" || path == "Assets/";
if (pathIsAssetsFolder)
{
var assetsFolderSelectionAllowed = Package.IsCompleteProject;
if (assetsFolderSelectionAllowed)
return true;
error = "'Assets' folder is only available for packages tagged as a 'Complete Project'.";
return false;
}
error = "Selected folder path must be within the project's Assets.";
return false;
}
public List<string> GetAvailableDependencies()
{
var registryPackages = PackageUtility.GetAllRegistryPackages();
return registryPackages.Select(x => x.name).ToList();
}
public List<string> GetAvailableSpecialFolders()
{
var specialFolders = new List<string>();
foreach (var extraAssetFolderName in _extraAssetFolderNames)
{
var fullExtraPath = "Assets/" + extraAssetFolderName;
if (!Directory.Exists(fullExtraPath))
continue;
if (_mainExportPath.ToLower().StartsWith(fullExtraPath.ToLower()))
continue;
// Don't include nested paths
if (!fullExtraPath.ToLower().StartsWith(_mainExportPath.ToLower()))
specialFolders.Add(fullExtraPath);
}
return specialFolders;
}
public override IEnumerable<string> GetAllPaths()
{
var paths = new List<string>()
{
_mainExportPath
};
paths.AddRange(GetSpecialFolders());
return paths;
}
public override IValidator CreateValidator()
{
var validationPaths = GetAllPaths();
var validationSettings = new CurrentProjectValidationSettings()
{
Category = Package.Category,
ValidationPaths = validationPaths.ToList(),
ValidationType = ValidationType.UnityPackage
};
var validator = new CurrentProjectValidator(validationSettings);
return validator;
}
public override IPackageExporter CreateExporter(string outputPath)
{
var exportPaths = GetAllPaths().ToList();
if (IsCompleteProject && !exportPaths.Contains("ProjectSettings"))
{
exportPaths.Add("ProjectSettings");
}
var dependenciesToInclude = new List<string>();
if (_includeDependencies)
{
dependenciesToInclude.AddRange(_dependencies.Select(x => x.name));
}
if (ASToolsPreferences.Instance.UseLegacyExporting)
{
var exportSettings = new LegacyExporterSettings()
{
ExportPaths = exportPaths.ToArray(),
OutputFilename = outputPath,
IncludeDependencies = _includeDependencies,
};
return new LegacyPackageExporter(exportSettings);
}
else
{
var exportSettings = new DefaultExporterSettings()
{
ExportPaths = exportPaths.ToArray(),
OutputFilename = outputPath,
Dependencies = dependenciesToInclude.ToArray(),
PreviewGenerator = CreatePreviewGenerator(exportPaths),
};
return new DefaultPackageExporter(exportSettings);
}
}
protected override IPackageUploader CreatePackageUploader(string exportedPackagePath)
{
var uploaderSettings = new UnityPackageUploadSettings()
{
UnityPackagePath = exportedPackagePath,
VersionId = Package.VersionId,
RootGuid = LocalPackageGuid,
RootPath = LocalPackagePath,
ProjectPath = LocalProjectPath
};
var uploader = new UnityPackageUploader(uploaderSettings);
return uploader;
}
protected override void Serialize()
{
_stateData.SetMainPath(_mainExportPath);
_stateData.SetIncludeDependencies(_includeDependencies);
_stateData.SetDependencies(_dependencies.Select(x => x.name));
_stateData.SetSpecialFolders(_specialFolders);
OnChanged?.Invoke();
}
protected override void Deserialize()
{
_mainExportPath = _stateData.GetMainPath();
_specialFolders = new List<string>();
foreach (var path in _stateData.GetSpecialFolders())
{
_specialFolders.Add(path);
}
_includeDependencies = _stateData.GetIncludeDependencies();
_dependencies = new List<PackageInfo>();
foreach (var dependency in _stateData.GetDependencies())
{
if (!PackageUtility.GetPackageByPackageName(dependency, out var package))
continue;
_dependencies.Add(package);
}
DeserializeFromUploadedData();
}
private void DeserializeFromUploadedData()
{
DeserializeFromUploadedDataByGuid();
DeserializeFromUploadedDataByPath();
}
private void DeserializeFromUploadedDataByGuid()
{
if (!string.IsNullOrEmpty(_mainExportPath))
return;
var lastUploadedGuid = Package.RootGuid;
if (string.IsNullOrEmpty(lastUploadedGuid))
return;
var potentialPackagePath = AssetDatabase.GUIDToAssetPath(lastUploadedGuid);
DeserializeFromUploadedDataByPath(potentialPackagePath);
}
private void DeserializeFromUploadedDataByPath()
{
if (!string.IsNullOrEmpty(_mainExportPath))
return;
var lastUploadedPath = Package.ProjectPath;
if (string.IsNullOrEmpty(lastUploadedPath))
return;
DeserializeFromUploadedDataByPath(lastUploadedPath);
}
private void DeserializeFromUploadedDataByPath(string path)
{
if (string.IsNullOrEmpty(path) || !IsPathValid(path, out var _))
return;
_mainExportPath = path;
}
}
}

8
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageUploadResult.cs.meta → Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/AssetsWorkflow.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 188361b01a1450145a6fc2a7aa0a3a3c
guid: 4657d35aaf9d70948a0840dc615f64ec
MonoImporter:
externalObjects: {}
serializedVersion: 2
@@ -13,6 +13,6 @@ AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 11.4.4
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageUploadResult.cs
uploadId: 712972
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/AssetsWorkflow.cs
uploadId: 724584

251
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/HybridPackageWorkflow.cs Normal file
View File

@@ -0,0 +1,251 @@
using AssetStoreTools.Api;
using AssetStoreTools.Exporter;
using AssetStoreTools.Uploader.Data.Serialization;
using AssetStoreTools.Utility;
using AssetStoreTools.Validator;
using AssetStoreTools.Validator.Data;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEditor.PackageManager;
using PackageInfo = UnityEditor.PackageManager.PackageInfo;
using PackageManager = UnityEditor.PackageManager;
namespace AssetStoreTools.Uploader.Data
{
internal class HybridPackageWorkflow : WorkflowBase
{
public override string Name => "HybridPackageWorkflow";
public override string DisplayName => "Local UPM Package";
public override string PackageExtension => ".unitypackage";
public override bool IsPathSet => _packageInfo != null;
private HybridPackageWorkflowState _stateData;
private PackageInfo _packageInfo;
private List<PackageInfo> _dependencies;
public override event Action OnChanged;
public HybridPackageWorkflow(IPackage package, HybridPackageWorkflowState stateData, IWorkflowServices services)
: base(package, services)
{
_stateData = stateData;
Deserialize();
}
public PackageInfo GetPackage()
{
return _packageInfo;
}
public void SetPackage(PackageInfo packageInfo, bool serialize)
{
if (packageInfo == null)
throw new ArgumentException("Package is null");
_packageInfo = packageInfo;
SetMetadata();
if (serialize)
Serialize();
}
public void SetPackage(string packageManifestPath, bool serialize)
{
if (!PackageUtility.GetPackageByManifestPath(packageManifestPath, out var package))
throw new ArgumentException("Path does not correspond to a valid package");
SetPackage(package, serialize);
}
private void SetMetadata()
{
LocalPackageGuid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(_packageInfo.GetManifestAsset()));
LocalPackagePath = _packageInfo.assetPath;
LocalProjectPath = _packageInfo.name;
}
public List<PackageInfo> GetDependencies()
{
return _dependencies;
}
public void SetDependencies(IEnumerable<string> dependencies, bool serialize)
{
_dependencies.Clear();
foreach (var dependency in dependencies)
{
if (!PackageUtility.GetPackageByPackageName(dependency, out var package))
continue;
_dependencies.Add(package);
}
if (serialize)
Serialize();
}
public List<PackageInfo> GetAvailableDependencies()
{
var availableDependencies = new List<PackageInfo>();
if (_packageInfo == null)
return availableDependencies;
var packageDependencies = _packageInfo.dependencies.Select(x => x.name);
foreach (var dependency in packageDependencies)
{
if (!PackageUtility.GetPackageByPackageName(dependency, out var package))
continue;
if (package.source != PackageManager.PackageSource.Local
&& package.source != PackageManager.PackageSource.Embedded)
continue;
availableDependencies.Add(package);
}
return availableDependencies;
}
public override IEnumerable<string> GetAllPaths()
{
var paths = new List<string>();
if (_packageInfo == null)
return paths;
paths.Add(_packageInfo.assetPath);
paths.AddRange(_dependencies.Select(x => x.assetPath));
return paths;
}
public override bool IsPathValid(string path, out string reason)
{
reason = string.Empty;
if (!PackageUtility.GetPackageByManifestPath(path, out var package))
{
reason = "Selected path must point to a package manifest for a package that is imported into the current project";
return false;
}
var packageSourceValid = package.source == PackageSource.Embedded || package.source == PackageSource.Local;
if (!packageSourceValid)
{
reason = "Selected package must be a local or an embedded package";
return false;
}
return true;
}
public override IValidator CreateValidator()
{
var validationPaths = GetAllPaths();
var validationSettings = new CurrentProjectValidationSettings()
{
Category = Package?.Category,
ValidationPaths = validationPaths.ToList(),
ValidationType = ValidationType.UnityPackage
};
var validator = new CurrentProjectValidator(validationSettings);
return validator;
}
public override IPackageExporter CreateExporter(string outputPath)
{
var exportPaths = GetAllPaths();
var exportSettings = new DefaultExporterSettings()
{
ExportPaths = exportPaths.ToArray(),
OutputFilename = outputPath,
PreviewGenerator = CreatePreviewGenerator(exportPaths.ToList())
};
return new DefaultPackageExporter(exportSettings);
}
protected override IPackageUploader CreatePackageUploader(string exportedPackagePath)
{
var uploaderSettings = new UnityPackageUploadSettings()
{
UnityPackagePath = exportedPackagePath,
VersionId = Package.VersionId,
RootGuid = LocalPackageGuid,
RootPath = LocalPackagePath,
ProjectPath = LocalProjectPath
};
var uploader = new UnityPackageUploader(uploaderSettings);
return uploader;
}
protected override void Serialize()
{
if (_packageInfo == null)
return;
_stateData.SetPackageName(_packageInfo.name);
_stateData.SetPackageDependencies(_dependencies.Select(x => x.name).OrderBy(x => x));
OnChanged?.Invoke();
}
protected override void Deserialize()
{
var packageName = _stateData.GetPackageName();
if (PackageUtility.GetPackageByPackageName(packageName, out var package))
_packageInfo = package;
_dependencies = new List<PackageInfo>();
var dependencies = _stateData.GetPackageDependencies();
foreach (var dependency in dependencies)
{
if (PackageUtility.GetPackageByPackageName(dependency, out var packageDependency))
_dependencies.Add(packageDependency);
}
DeserializeFromUploadedData();
}
private void DeserializeFromUploadedData()
{
DeserializeFromUploadedDataByPackageName();
DeserializeFromUploadedDataByPackageGuid();
}
private void DeserializeFromUploadedDataByPackageName()
{
if (_packageInfo != null)
return;
var lastUploadedPackageName = Package.ProjectPath;
if (!PackageUtility.GetPackageByPackageName(lastUploadedPackageName, out var package))
return;
_packageInfo = package;
}
private void DeserializeFromUploadedDataByPackageGuid()
{
if (_packageInfo != null)
return;
var lastUploadedGuid = Package.RootGuid;
if (string.IsNullOrEmpty(lastUploadedGuid))
return;
var potentialPackageManifestPath = AssetDatabase.GUIDToAssetPath(lastUploadedGuid);
if (string.IsNullOrEmpty(potentialPackageManifestPath) || !IsPathValid(potentialPackageManifestPath, out var _))
return;
if (!PackageUtility.GetPackageByManifestPath(potentialPackageManifestPath, out var package))
return;
_packageInfo = package;
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/HybridPackageWorkflow.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 3061839aba3894246a20195639eeda1f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/HybridPackageWorkflow.cs
uploadId: 724584

39
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/OngoingUpload.cs
View File

@@ -1,39 +0,0 @@
using System;
using System.Threading;
namespace AssetStoreTools.Uploader.Data
{
internal class OngoingUpload : IDisposable
{
private CancellationTokenSource _cancellationTokenSource;
public string VersionId { get; }
public string PackageName { get; }
public float Progress { get; private set; }
public CancellationToken CancellationToken => _cancellationTokenSource.Token;
public OngoingUpload(string versionId, string packageName)
{
VersionId = versionId;
PackageName = packageName;
Progress = 0f;
_cancellationTokenSource = new CancellationTokenSource();
}
public void Cancel()
{
_cancellationTokenSource?.Cancel();
}
public void Dispose()
{
_cancellationTokenSource?.Dispose();
_cancellationTokenSource = null;
}
public void UpdateProgress(float newProgress)
{
Progress = newProgress;
}
}
}

91
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Package.cs Normal file
View File

@@ -0,0 +1,91 @@
using System;
using UnityEngine;
using PackageModel = AssetStoreTools.Api.Models.Package;
namespace AssetStoreTools.Uploader.Data
{
internal class Package : IPackage
{
private PackageModel _source;
public string PackageId => _source.PackageId;
public string VersionId => _source.VersionId;
public string Name => _source.Name;
public string Status => _source.Status;
public string Category => _source.Category;
public bool IsCompleteProject => _source.IsCompleteProject;
public string RootGuid => _source.RootGuid;
public string RootPath => _source.RootPath;
public string ProjectPath => _source.ProjectPath;
public string Modified => _source.Modified;
public string Size => _source.Size;
public string IconUrl => _source.IconUrl;
public bool IsDraft => Status.Equals("draft", StringComparison.OrdinalIgnoreCase);
public Texture2D Icon { get; private set; }
public event Action OnUpdate;
public event Action OnIconUpdate;
public Package(PackageModel packageSource)
{
_source = packageSource;
}
public void UpdateIcon(Texture2D texture)
{
if (texture == null)
return;
Icon = texture;
OnIconUpdate?.Invoke();
}
public string FormattedSize()
{
var defaultSize = "0.00 MB";
if (float.TryParse(Size, out var sizeBytes))
return $"{sizeBytes / (1024f * 1024f):0.00} MB";
return defaultSize;
}
public string FormattedModified()
{
var defaultDate = "Unknown";
if (DateTime.TryParse(Modified, out var dt))
return dt.Date.ToString("yyyy-MM-dd");
return defaultDate;
}
public void UpdateData(PackageModel source)
{
if (source == null)
throw new ArgumentException("Provided package is null");
_source = source;
OnUpdate?.Invoke();
}
public PackageModel ToModel()
{
var model = new PackageModel()
{
PackageId = _source.PackageId,
VersionId = _source.VersionId,
Name = _source.Name,
Status = _source.Status,
Category = _source.Category,
IsCompleteProject = _source.IsCompleteProject,
RootGuid = _source.RootGuid,
RootPath = _source.RootPath,
ProjectPath = _source.ProjectPath,
Modified = _source.Modified,
Size = _source.Size,
IconUrl = _source.IconUrl
};
return model;
}
}
}

8
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/OngoingUpload.cs.meta → Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Package.cs.meta
View File

@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 601fdada4edc5b94eb83a21d1a01ed26
guid: fc2198164bbd6394b87c51a74fe2915e
MonoImporter:
externalObjects: {}
serializedVersion: 2
@@ -13,6 +13,6 @@ AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 11.4.4
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/OngoingUpload.cs
uploadId: 712972
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Package.cs
uploadId: 724584

68
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageContent.cs Normal file
View File

@@ -0,0 +1,68 @@
using AssetStoreTools.Uploader.Data.Serialization;
using AssetStoreTools.Uploader.Services;
using System;
using System.Collections.Generic;
using System.Linq;
namespace AssetStoreTools.Uploader.Data
{
internal class PackageContent : IPackageContent
{
private IWorkflow _activeWorkflow;
private List<IWorkflow> _workflows;
private WorkflowStateData _workflowStateData;
private ICachingService _cachingService;
public event Action<IWorkflow> OnActiveWorkflowChanged;
public PackageContent(List<IWorkflow> workflows, WorkflowStateData workflowStateData, ICachingService cachingService)
{
_workflows = workflows;
_workflowStateData = workflowStateData;
_cachingService = cachingService;
foreach (var workflow in _workflows)
{
workflow.OnChanged += Serialize;
}
Deserialize();
}
public IWorkflow GetActiveWorkflow()
{
return _activeWorkflow;
}
public void SetActiveWorkflow(IWorkflow workflow)
{
_activeWorkflow = workflow;
OnActiveWorkflowChanged?.Invoke(_activeWorkflow);
Serialize();
}
public List<IWorkflow> GetAvailableWorkflows()
{
return _workflows;
}
private void Serialize()
{
_workflowStateData.SetActiveWorkflow(_activeWorkflow.Name);
_cachingService.CacheWorkflowStateData(_workflowStateData);
}
private void Deserialize()
{
var serializedWorkflow = _workflowStateData.GetActiveWorkflow();
var workflow = _workflows.FirstOrDefault(x => x.Name == serializedWorkflow);
if (workflow != null)
_activeWorkflow = workflow;
else
_activeWorkflow = _workflows[0];
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageContent.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: f36086f9380a49949ab45463abc6fee8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageContent.cs
uploadId: 724584

36
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageData.cs
View File

@@ -1,36 +0,0 @@
namespace AssetStoreTools.Uploader.Data
{
internal class PackageData
{
public string Id { get; }
public string Name { get; }
public string VersionId { get; }
public string Status { get; }
public string Category { get; }
public bool IsCompleteProject { get; }
public string LastUploadedPath { get; }
public string LastUploadedGuid { get; }
public string LastDate { get; }
public string LastSize { get; }
public PackageData(string id, string name, string versionId, string status, string category, bool isCompleteProject, string lastUploadedPath, string lastUploadedGuid, string lastDate, string lastSize)
{
Id = id;
Name = name;
VersionId = versionId;
Status = status;
Category = category;
IsCompleteProject = isCompleteProject;
LastUploadedPath = lastUploadedPath;
LastUploadedGuid = lastUploadedGuid;
LastDate = lastDate;
LastSize = lastSize;
}
public override string ToString()
{
return $"{Id} {Name} {VersionId} {Status} {Category} {LastUploadedPath} {LastUploadedGuid} {IsCompleteProject} {LastDate} {LastSize}";
}
}
}

10
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageData.cs.meta
View File

@@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 8157930875be4972a48c870a3d1e8ff1
timeCreated: 1658919930
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 11.4.4
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageData.cs
uploadId: 712972

64
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageGroup.cs Normal file
View File

@@ -0,0 +1,64 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace AssetStoreTools.Uploader.Data
{
internal class PackageGroup : IPackageGroup
{
private class FilteredPackage
{
public IPackage Package;
public bool IsInFilter;
}
public string Name { get; private set; }
public List<IPackage> Packages { get; private set; }
private List<FilteredPackage> _filteredPackages;
public event Action<List<IPackage>> OnPackagesSorted;
public event Action<List<IPackage>> OnPackagesFiltered;
public PackageGroup(string name, List<IPackage> packages)
{
Name = name;
Packages = packages;
_filteredPackages = new List<FilteredPackage>();
foreach (var package in Packages)
_filteredPackages.Add(new FilteredPackage() { Package = package, IsInFilter = true });
}
public void Sort(PackageSorting sortingType)
{
switch (sortingType)
{
case PackageSorting.Name:
_filteredPackages = _filteredPackages.OrderBy(x => x.Package.Name).ToList();
break;
case PackageSorting.Date:
_filteredPackages = _filteredPackages.OrderByDescending(x => x.Package.Modified).ToList();
break;
case PackageSorting.Category:
_filteredPackages = _filteredPackages.OrderBy(x => x.Package.Category).ThenBy(x => x.Package.Name).ToList();
break;
default:
throw new NotImplementedException("Undefined sorting type");
}
OnPackagesSorted?.Invoke(_filteredPackages.Where(x => x.IsInFilter).Select(x => x.Package).ToList());
}
public void Filter(string filter)
{
foreach (var package in _filteredPackages)
{
bool inFilter = package.Package.Name.ToLower().Contains(filter.ToLower());
package.IsInFilter = inFilter;
}
OnPackagesFiltered?.Invoke(_filteredPackages.Where(x => x.IsInFilter).Select(x => x.Package).ToList());
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageGroup.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: c9cc17f6b95bb2c42913a1451b9af29e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageGroup.cs
uploadId: 724584

9
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageSorting.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace AssetStoreTools.Uploader.Data
{
internal enum PackageSorting
{
Name,
Category,
Date
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageSorting.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: b1d61d0de90e022469b5ed312d4b7beb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageSorting.cs
uploadId: 724584

46
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/PackageUploadResult.cs
View File

@@ -1,46 +0,0 @@
using AssetStoreTools.Utility;
using UnityEngine;
namespace AssetStoreTools.Uploader.Data
{
internal class PackageUploadResult
{
public enum UploadStatus
{
Default = 0,
Success = 1,
Fail = 2,
Cancelled = 3,
ResponseTimeout = 4
}
public UploadStatus Status;
public ASError Error;
private PackageUploadResult() { }
public static PackageUploadResult PackageUploadSuccess() => new PackageUploadResult() { Status = UploadStatus.Success };
public static PackageUploadResult PackageUploadFail(ASError e) => new PackageUploadResult() { Status = UploadStatus.Fail, Error = e };
public static PackageUploadResult PackageUploadCancelled() => new PackageUploadResult() { Status = UploadStatus.Cancelled };
public static PackageUploadResult PackageUploadResponseTimeout() => new PackageUploadResult() { Status = UploadStatus.ResponseTimeout };
public static Color GetColorByStatus(UploadStatus status)
{
switch (status)
{
default:
case UploadStatus.Default:
return new Color(0.13f, 0.59f, 0.95f);
case UploadStatus.Success:
return new Color(0f, 0.50f, 0.14f);
case UploadStatus.Cancelled:
return new Color(0.78f, 0.59f, 0f);
case UploadStatus.Fail:
return new Color(0.69f, 0.04f, 0.04f);
}
}
}
}

8
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 0b05e199f21f636439844a8cc7e2c225
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

59
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/AssetPath.cs Normal file
View File

@@ -0,0 +1,59 @@
using AssetStoreTools.Utility;
using Newtonsoft.Json;
using System.IO;
using UnityEditor;
namespace AssetStoreTools.Uploader.Data.Serialization
{
internal class AssetPath
{
[JsonProperty("path")]
private string _path = string.Empty;
[JsonProperty("guid")]
private string _guid = string.Empty;
[JsonIgnore]
public string Path { get => _path; set { SetAssetPath(value); } }
[JsonIgnore]
public string Guid { get => _guid; set { _guid = value; } }
public AssetPath() { }
public AssetPath(string path)
{
SetAssetPath(path);
}
private void SetAssetPath(string path)
{
_path = path.Replace("\\", "/");
if (TryGetGuid(_path, out var guid))
_guid = guid;
}
private bool TryGetGuid(string path, out string guid)
{
guid = string.Empty;
var relativePath = FileUtility.AbsolutePathToRelativePath(path, ASToolsPreferences.Instance.EnableSymlinkSupport);
if (!relativePath.StartsWith("Assets/") && !relativePath.StartsWith("Packages/"))
return false;
guid = AssetDatabase.AssetPathToGUID(relativePath);
return !string.IsNullOrEmpty(guid);
}
public override string ToString()
{
var pathFromGuid = AssetDatabase.GUIDToAssetPath(_guid);
if (!string.IsNullOrEmpty(pathFromGuid) && (File.Exists(pathFromGuid) || Directory.Exists(pathFromGuid)))
return pathFromGuid;
if (File.Exists(_path) || Directory.Exists(_path))
return _path;
return string.Empty;
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/AssetPath.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 920ff8e4ffe77ec44bede985593cc187
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/AssetPath.cs
uploadId: 724584

77
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/AssetsWorkflowStateData.cs Normal file
View File

@@ -0,0 +1,77 @@
using Newtonsoft.Json;
using System.Collections.Generic;
namespace AssetStoreTools.Uploader.Data.Serialization
{
internal class AssetsWorkflowState
{
[JsonProperty("main_path")]
private AssetPath _mainPath;
[JsonProperty("special_folders")]
private List<AssetPath> _specialFolders;
[JsonProperty("include_dependencies")]
private bool _includeDependencies;
[JsonProperty("dependencies")]
private List<string> _dependencies;
public AssetsWorkflowState()
{
_mainPath = new AssetPath();
_includeDependencies = false;
_dependencies = new List<string>();
_specialFolders = new List<AssetPath>();
}
public string GetMainPath()
{
return _mainPath?.ToString();
}
public void SetMainPath(string path)
{
_mainPath = new AssetPath(path);
}
public bool GetIncludeDependencies()
{
return _includeDependencies;
}
public void SetIncludeDependencies(bool value)
{
_includeDependencies = value;
}
public List<string> GetDependencies()
{
return _dependencies;
}
public void SetDependencies(IEnumerable<string> dependencies)
{
_dependencies = new List<string>();
foreach (var dependency in dependencies)
_dependencies.Add(dependency);
}
public List<string> GetSpecialFolders()
{
var specialFolders = new List<string>();
foreach (var folder in _specialFolders)
{
var path = folder.ToString();
if (!string.IsNullOrEmpty(path))
specialFolders.Add(path);
}
return specialFolders;
}
public void SetSpecialFolders(List<string> specialFolders)
{
_specialFolders = new List<AssetPath>();
foreach (var path in specialFolders)
_specialFolders.Add(new AssetPath(path));
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/AssetsWorkflowStateData.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 505f0a5aa753b4445a467539e150190a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/AssetsWorkflowStateData.cs
uploadId: 724584

41
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/HybridPackageWorkflowState.cs Normal file
View File

@@ -0,0 +1,41 @@
using Newtonsoft.Json;
using System.Collections.Generic;
namespace AssetStoreTools.Uploader.Data.Serialization
{
internal class HybridPackageWorkflowState
{
[JsonProperty("package_name")]
private string _packageName;
[JsonProperty("dependencies")]
private List<string> _dependencies;
public HybridPackageWorkflowState()
{
_packageName = string.Empty;
_dependencies = new List<string>();
}
public string GetPackageName()
{
return _packageName;
}
public void SetPackageName(string packageName)
{
_packageName = packageName;
}
public List<string> GetPackageDependencies()
{
return _dependencies;
}
public void SetPackageDependencies(IEnumerable<string> dependencies)
{
_dependencies.Clear();
foreach (var dependency in dependencies)
_dependencies.Add(dependency);
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/HybridPackageWorkflowState.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 2848375fcb0a4174495573190bfc3900
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/HybridPackageWorkflowState.cs
uploadId: 724584

25
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/UnityPackageWorkflowStateData.cs Normal file
View File

@@ -0,0 +1,25 @@
using Newtonsoft.Json;
namespace AssetStoreTools.Uploader.Data.Serialization
{
internal class UnityPackageWorkflowState
{
[JsonProperty("package_path")]
private AssetPath _packagePath;
public UnityPackageWorkflowState()
{
_packagePath = new AssetPath();
}
public string GetPackagePath()
{
return _packagePath?.ToString();
}
public void SetPackagePath(string path)
{
_packagePath = new AssetPath(path);
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/UnityPackageWorkflowStateData.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 101a66adc88639b43b07cc28214474cf
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/UnityPackageWorkflowStateData.cs
uploadId: 724584

68
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/WorkflowStateData.cs Normal file
View File

@@ -0,0 +1,68 @@
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
namespace AssetStoreTools.Uploader.Data.Serialization
{
internal class WorkflowStateData
{
[JsonProperty("package_id")]
private string _packageId;
[JsonProperty("active_workflow")]
private string _activeWorkflow;
[JsonProperty("assets_workflow")]
private AssetsWorkflowState _assetsWorkflow;
[JsonProperty("unitypackage_workflow")]
private UnityPackageWorkflowState _unityPackageWorkflow;
[JsonProperty("hybrid_workflow")]
private HybridPackageWorkflowState _hybridPackageWorkflow;
public WorkflowStateData()
{
_activeWorkflow = string.Empty;
_assetsWorkflow = new AssetsWorkflowState();
_unityPackageWorkflow = new UnityPackageWorkflowState();
_hybridPackageWorkflow = new HybridPackageWorkflowState();
}
public WorkflowStateData(string packageId) : this()
{
SetPackageId(packageId);
}
public string GetPackageId()
{
return _packageId;
}
public void SetPackageId(string packageId)
{
_packageId = packageId;
}
public string GetActiveWorkflow()
{
return _activeWorkflow;
}
public void SetActiveWorkflow(string activeWorkflow)
{
_activeWorkflow = activeWorkflow;
}
public AssetsWorkflowState GetAssetsWorkflowState()
{
return _assetsWorkflow;
}
public UnityPackageWorkflowState GetUnityPackageWorkflowState()
{
return _unityPackageWorkflow;
}
public HybridPackageWorkflowState GetHybridPackageWorkflowState()
{
return _hybridPackageWorkflow;
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/WorkflowStateData.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: eecebbc83661a4f41a14e293c9fc3331
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/Serialization/WorkflowStateData.cs
uploadId: 724584

135
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/UnityPackageWorkflow.cs Normal file
View File

@@ -0,0 +1,135 @@
using AssetStoreTools.Api;
using AssetStoreTools.Exporter;
using AssetStoreTools.Uploader.Data.Serialization;
using AssetStoreTools.Validator;
using AssetStoreTools.Validator.Data;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace AssetStoreTools.Uploader.Data
{
internal class UnityPackageWorkflow : WorkflowBase
{
public override string Name => "UnityPackageWorkflow";
public override string DisplayName => "Pre-exported .unitypackage";
public override string PackageExtension => ".unitypackage";
public override bool IsPathSet => !string.IsNullOrEmpty(_packagePath);
private UnityPackageWorkflowState _workflowState;
private string _packagePath;
public override event Action OnChanged;
public UnityPackageWorkflow(IPackage package, UnityPackageWorkflowState workflowState, IWorkflowServices services)
: base(package, services)
{
_workflowState = workflowState;
Deserialize();
}
public void SetPackagePath(string path, bool serialize)
{
_packagePath = path;
SetMetadata();
if (serialize)
Serialize();
}
private void SetMetadata()
{
LocalPackageGuid = string.Empty;
LocalPackagePath = string.Empty;
LocalProjectPath = _packagePath;
}
public string GetPackagePath()
{
return _packagePath;
}
public override IEnumerable<string> GetAllPaths()
{
return new List<string>() { _packagePath };
}
public override bool IsPathValid(string path, out string error)
{
error = null;
var pathIsUnityPackage = path.EndsWith(PackageExtension);
var pathExists = File.Exists(path);
if (!pathIsUnityPackage || !pathExists)
{
error = "Path must point to a .unitypackage file";
return false;
}
return true;
}
public override IValidator CreateValidator()
{
var validationSettings = new ExternalProjectValidationSettings()
{
Category = Package.Category,
PackagePath = GetPackagePath()
};
var validator = new ExternalProjectValidator(validationSettings);
return validator;
}
public override IPackageExporter CreateExporter(string _)
{
// This workflow already takes exported packages as input
throw new InvalidOperationException($"{nameof(UnityPackageWorkflow)} already takes exported packages as input");
}
public override Task<PackageExporterResult> ExportPackage(string _)
{
return Task.FromResult(new PackageExporterResult() { Success = true, ExportedPath = GetPackagePath() });
}
protected override IPackageUploader CreatePackageUploader(string exportedPackagePath)
{
var uploaderSettings = new UnityPackageUploadSettings()
{
VersionId = Package.VersionId,
UnityPackagePath = exportedPackagePath,
RootGuid = LocalPackageGuid,
RootPath = LocalPackagePath,
ProjectPath = LocalProjectPath
};
var uploader = new UnityPackageUploader(uploaderSettings);
return uploader;
}
protected override void Serialize()
{
_workflowState.SetPackagePath(_packagePath);
OnChanged?.Invoke();
}
protected override void Deserialize()
{
_packagePath = _workflowState.GetPackagePath();
DeserializeFromUploadedData();
}
private void DeserializeFromUploadedData()
{
if (!string.IsNullOrEmpty(_packagePath))
return;
var potentialPackagePath = Package.ProjectPath;
if (string.IsNullOrEmpty(potentialPackagePath) || !IsPathValid(potentialPackagePath, out var _))
return;
_packagePath = potentialPackagePath;
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/UnityPackageWorkflow.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 47ee1db30792bf84aa1af8be7ce0dee6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/UnityPackageWorkflow.cs
uploadId: 724584

53
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/WorkflowServices.cs Normal file
View File

@@ -0,0 +1,53 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Uploader.Services.Analytics;
using AssetStoreTools.Uploader.Services.Analytics.Data;
using AssetStoreTools.Uploader.Services.Api;
using System;
using System.Threading.Tasks;
using UnityEngine.Analytics;
namespace AssetStoreTools.Uploader.Data
{
internal class WorkflowServices : IWorkflowServices
{
private IPackageDownloadingService _downloadingService;
private IPackageUploadingService _uploadingService;
private IAnalyticsService _analyticsService;
public WorkflowServices(
IPackageDownloadingService downloadingService,
IPackageUploadingService uploadingService,
IAnalyticsService analyticsService)
{
_downloadingService = downloadingService;
_uploadingService = uploadingService;
_analyticsService = analyticsService;
}
public Task<PackageUploadedUnityVersionDataResponse> GetPackageUploadedVersions(IPackage package, int timeoutMs)
{
return _downloadingService.GetPackageUploadedVersions(package, timeoutMs);
}
public Task<PackageUploadResponse> UploadPackage(IPackageUploader uploader, IProgress<float> progress)
{
return _uploadingService.UploadPackage(uploader, progress);
}
public void StopUploading(IPackageUploader uploader)
{
_uploadingService.StopUploading(uploader);
}
public Task<RefreshedPackageDataResponse> UpdatePackageData(IPackage package)
{
return _downloadingService.UpdatePackageData(package);
}
public AnalyticsResult SendAnalytic(IAssetStoreAnalytic data)
{
return _analyticsService.Send(data);
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/WorkflowServices.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: a78b96ae30966e94ba9ffdddf19c1692
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 115
packageName: Asset Store Publishing Tools
packageVersion: 12.0.1
assetPath: Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Data/WorkflowServices.cs
uploadId: 724584