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

100
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/AuthenticationService.cs Normal file
View File

@@ -0,0 +1,100 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Models;
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Uploader.Services.Analytics;
using AssetStoreTools.Uploader.Services.Analytics.Data;
using AssetStoreTools.Utility;
using System;
using System.Threading.Tasks;
using UnityEditor;
namespace AssetStoreTools.Uploader.Services.Api
{
internal class AuthenticationService : IAuthenticationService
{
private IAssetStoreApi _api;
private ICachingService _cachingService;
private IAnalyticsService _analyticsService;
public User User { get; private set; }
public AuthenticationService(IAssetStoreApi api, ICachingService cachingService, IAnalyticsService analyticsService)
{
_api = api;
_cachingService = cachingService;
_analyticsService = analyticsService;
}
public async Task<AuthenticationResponse> AuthenticateWithCredentials(string email, string password)
{
var authenticationType = new CredentialsAuthentication(email, password);
return await Authenticate(authenticationType);
}
public async Task<AuthenticationResponse> AuthenticateWithSessionToken()
{
if (!_cachingService.GetCachedSessionToken(out var cachedSessionToken))
{
return new AuthenticationResponse() { Success = false, Exception = new Exception("No cached session token found") };
}
var authenticationType = new SessionAuthentication(cachedSessionToken);
return await Authenticate(authenticationType);
}
public async Task<AuthenticationResponse> AuthenticateWithCloudToken()
{
var authenticationType = new CloudTokenAuthentication(CloudProjectSettings.accessToken);
return await Authenticate(authenticationType);
}
private async Task<AuthenticationResponse> Authenticate(IAuthenticationType authenticationType)
{
var response = await _api.Authenticate(authenticationType);
HandleLoginResponse(authenticationType, response);
return response;
}
private void HandleLoginResponse(IAuthenticationType authenticationType, AuthenticationResponse response)
{
if (!response.Success)
{
Deauthenticate();
return;
}
User = response.User;
_cachingService.CacheSessionToken(User.SessionId);
SendAnalytics(authenticationType, User);
}
public bool CloudAuthenticationAvailable(out string username, out string cloudToken)
{
username = CloudProjectSettings.userName;
cloudToken = CloudProjectSettings.accessToken;
return !username.Equals("anonymous");
}
public void Deauthenticate()
{
_api.Deauthenticate();
User = null;
_cachingService.ClearCachedSessionToken();
}
private void SendAnalytics(IAuthenticationType authenticationType, User user)
{
try
{
// Do not send session authentication events
if (authenticationType is SessionAuthentication)
return;
var analytic = new AuthenticationAnalytic(authenticationType, user.PublisherId);
var result = _analyticsService.Send(analytic);
}
catch (Exception e) { ASDebug.LogError($"Could not send analytics: {e}"); }
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/AuthenticationService.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: c1c3d6578d298d049a8dcf858fd3686e
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/Services/Api/AuthenticationService.cs
uploadId: 724584

16
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/IAuthenticationService.cs Normal file
View File

@@ -0,0 +1,16 @@
using AssetStoreTools.Api.Models;
using AssetStoreTools.Api.Responses;
using System.Threading.Tasks;
namespace AssetStoreTools.Uploader.Services.Api
{
internal interface IAuthenticationService : IUploaderService
{
User User { get; }
Task<AuthenticationResponse> AuthenticateWithCredentials(string email, string password);
Task<AuthenticationResponse> AuthenticateWithSessionToken();
Task<AuthenticationResponse> AuthenticateWithCloudToken();
bool CloudAuthenticationAvailable(out string username, out string cloudToken);
void Deauthenticate();
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/IAuthenticationService.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: ff0518dc0d95d3540857d138215bb900
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/Services/Api/IAuthenticationService.cs
uploadId: 724584

16
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/IPackageDownloadingService.cs Normal file
View File

@@ -0,0 +1,16 @@
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Uploader.Data;
using System.Threading.Tasks;
namespace AssetStoreTools.Uploader.Services.Api
{
internal interface IPackageDownloadingService : IUploaderService
{
Task<PackagesDataResponse> GetPackageData();
Task<RefreshedPackageDataResponse> UpdatePackageData(IPackage package);
void ClearPackageData();
Task<PackageThumbnailResponse> GetPackageThumbnail(IPackage package);
Task<PackageUploadedUnityVersionDataResponse> GetPackageUploadedVersions(IPackage package, int timeoutMs);
void StopDownloading();
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/IPackageDownloadingService.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 96acd12a628311d429cc285f418f8b90
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/Services/Api/IPackageDownloadingService.cs
uploadId: 724584

16
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/IPackageUploadingService.cs Normal file
View File

@@ -0,0 +1,16 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using System;
using System.Threading.Tasks;
namespace AssetStoreTools.Uploader.Services.Api
{
internal interface IPackageUploadingService : IUploaderService
{
bool IsUploading { get; }
Task<PackageUploadResponse> UploadPackage(IPackageUploader uploader, IProgress<float> progress);
void StopUploading(IPackageUploader package);
void StopAllUploadinng();
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/IPackageUploadingService.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 9a3d78f3bc68d3d44b4300bc8ffe69c2
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/Services/Api/IPackageUploadingService.cs
uploadId: 724584

109
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/PackageDownloadingService.cs Normal file
View File

@@ -0,0 +1,109 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using AssetStoreTools.Uploader.Data;
using System.Threading;
using System.Threading.Tasks;
namespace AssetStoreTools.Uploader.Services.Api
{
internal class PackageDownloadingService : IPackageDownloadingService
{
public const int MaxConcurrentTumbnailDownloads = 10;
private IAssetStoreApi _api;
private ICachingService _cachingService;
private int _currentDownloads;
private CancellationTokenSource _cancellationTokenSource;
public PackageDownloadingService(IAssetStoreApi api, ICachingService cachingService)
{
_api = api;
_cachingService = cachingService;
_cancellationTokenSource = new CancellationTokenSource();
}
public void ClearPackageData()
{
_cachingService.DeletePackageMetadata();
}
public async Task<PackagesDataResponse> GetPackageData()
{
if (!_cachingService.GetCachedPackageMetadata(out var models))
{
var cancellationToken = _cancellationTokenSource.Token;
var packagesResponse = await _api.GetPackages(cancellationToken);
if (packagesResponse.Cancelled || !packagesResponse.Success)
return packagesResponse;
_cachingService.CachePackageMetadata(packagesResponse.Packages);
return packagesResponse;
}
return new PackagesDataResponse() { Success = true, Packages = models };
}
public async Task<RefreshedPackageDataResponse> UpdatePackageData(IPackage package)
{
var response = await _api.RefreshPackageMetadata(package.ToModel());
if (response.Success)
_cachingService.UpdatePackageMetadata(response.Package);
return response;
}
public async Task<PackageThumbnailResponse> GetPackageThumbnail(IPackage package)
{
if (_cachingService.GetCachedPackageThumbnail(package.PackageId, out var cachedTexture))
{
return new PackageThumbnailResponse() { Success = true, Thumbnail = cachedTexture };
}
var cancellationToken = _cancellationTokenSource.Token;
while (_currentDownloads >= MaxConcurrentTumbnailDownloads)
await Task.Delay(100);
if (cancellationToken.IsCancellationRequested)
return new PackageThumbnailResponse() { Success = false, Cancelled = true };
_currentDownloads++;
var result = await _api.GetPackageThumbnail(package.ToModel(), cancellationToken);
_currentDownloads--;
if (result.Success && result.Thumbnail != null)
_cachingService.CachePackageThumbnail(package.PackageId, result.Thumbnail);
return result;
}
public async Task<PackageUploadedUnityVersionDataResponse> GetPackageUploadedVersions(IPackage package, int timeoutMs)
{
var timeoutTokenSource = new CancellationTokenSource();
try
{
var versionsTask = _api.GetPackageUploadedVersions(package.ToModel(), timeoutTokenSource.Token);
// Wait for versions to be retrieved, or a timeout to occur, whichever is first
if (await Task.WhenAny(versionsTask, Task.Delay(timeoutMs)) != versionsTask)
{
timeoutTokenSource.Cancel();
}
return await versionsTask;
}
finally
{
timeoutTokenSource.Dispose();
}
}
public void StopDownloading()
{
_cancellationTokenSource.Cancel();
_cancellationTokenSource = new CancellationTokenSource();
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/PackageDownloadingService.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: adc44e974cb91b54fac3819284b7ba82
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/Services/Api/PackageDownloadingService.cs
uploadId: 724584

103
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/PackageUploadingService.cs Normal file
View File

@@ -0,0 +1,103 @@
using AssetStoreTools.Api;
using AssetStoreTools.Api.Responses;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using UnityEditor;
namespace AssetStoreTools.Uploader.Services.Api
{
internal class PackageUploadingService : IPackageUploadingService
{
private class UploadInProgress
{
public IPackageUploader Uploader;
public IProgress<float> Progress = new Progress<float>();
public CancellationTokenSource CancellationTokenSource = new CancellationTokenSource();
public UploadInProgress(IPackageUploader uploader, IProgress<float> progress)
{
Uploader = uploader;
Progress = progress;
CancellationTokenSource = new CancellationTokenSource();
}
}
private IAssetStoreApi _api;
private List<UploadInProgress> _uploadsInProgress;
public bool IsUploading => _uploadsInProgress.Count > 0;
public PackageUploadingService(IAssetStoreApi api)
{
_api = api;
_uploadsInProgress = new List<UploadInProgress>();
}
public async Task<PackageUploadResponse> UploadPackage(IPackageUploader uploader, IProgress<float> progress)
{
using (var cancellationTokenSource = new CancellationTokenSource())
{
var uploadInProgress = StartTrackingUpload(uploader, progress);
var response = await _api.UploadPackage(uploadInProgress.Uploader, uploadInProgress.Progress, uploadInProgress.CancellationTokenSource.Token);
StopTrackingUpload(uploadInProgress);
return response;
}
}
private UploadInProgress StartTrackingUpload(IPackageUploader uploader, IProgress<float> progress)
{
// If this is the first upload - lock reload assemblies and prevent entering play mode
if (_uploadsInProgress.Count == 0)
{
EditorApplication.LockReloadAssemblies();
EditorApplication.playModeStateChanged += PreventEnteringPlayMode;
}
var uploadInProgress = new UploadInProgress(uploader, progress);
_uploadsInProgress.Add(uploadInProgress);
return uploadInProgress;
}
private void StopTrackingUpload(UploadInProgress uploadInProgress)
{
_uploadsInProgress.Remove(uploadInProgress);
// If this was the last upload - unlock reload assemblies and allow entering play mode
if (_uploadsInProgress.Count > 0)
return;
EditorApplication.UnlockReloadAssemblies();
EditorApplication.playModeStateChanged -= PreventEnteringPlayMode;
}
private void PreventEnteringPlayMode(PlayModeStateChange change)
{
if (change != PlayModeStateChange.ExitingEditMode)
return;
EditorApplication.ExitPlaymode();
EditorUtility.DisplayDialog("Notice", "Entering Play Mode is not allowed while there's a package upload in progress.\n\n" +
"Please wait until the upload is finished or cancel the upload from the Asset Store Uploader window", "OK");
}
public void StopUploading(IPackageUploader uploader)
{
var uploadInProgress = _uploadsInProgress.FirstOrDefault(x => x.Uploader == uploader);
if (uploadInProgress == null)
return;
uploadInProgress.CancellationTokenSource.Cancel();
}
public void StopAllUploadinng()
{
foreach (var uploadInProgress in _uploadsInProgress)
uploadInProgress.CancellationTokenSource.Cancel();
}
}
}

18
Packages/com.unity.asset-store-tools/Editor/Uploader/Scripts/Services/Api/PackageUploadingService.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 22e23997fe339a74bb5355d6a88ce731
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/Services/Api/PackageUploadingService.cs
uploadId: 724584