LoadSmartWearableSceneSystem.cs

using Arch.SystemGroups;
using CommunicationData.URLHelpers;
using Cysharp.Threading.Tasks;
using DCL.AvatarRendering.Wearables.Components;
using DCL.AvatarRendering.Wearables.Helpers;
using DCL.Diagnostics;
using DCL.Ipfs;
using DCL.Multiplayer.Connections.DecentralandUrls;
using DCL.WebRequests;
using ECS.Prioritization.Components;
using ECS.SceneLifeCycle.SceneDefinition;
using ECS.StreamableLoading.Cache;
using ECS.StreamableLoading.Common.Components;
using ECS.StreamableLoading.Common.Systems;
using Runtime.Wearables;
using SceneRunner;
using SceneRunner.Scene;
using SceneRuntime.ScenePermissions;
using System;
using System.Threading;

namespace ECS.SceneLifeCycle.Systems
{
    /// <summary>
    /// Handles the <see cref="GetSmartWearableSceneIntention"/> to load the actual scene associated with the smart wearable.
    /// </summary>
    [UpdateInGroup(typeof(RealmGroup))]
    public partial class LoadSmartWearableSceneSystem : LoadSystemBase<GetSmartWearableSceneIntention.Result, GetSmartWearableSceneIntention>
    {
        private readonly ISceneFactory sceneFactory;
        private readonly IWebRequestController webRequestController;
        private readonly SmartWearableCache smartWearableCache;
        private readonly IDecentralandUrlsSource urlsSource;

        public LoadSmartWearableSceneSystem(
            Arch.Core.World world,
            IStreamableCache<GetSmartWearableSceneIntention.Result, GetSmartWearableSceneIntention> cache,
            IWebRequestController webRequestController,
            ISceneFactory sceneFactory,
            SmartWearableCache smartWearableCache, IDecentralandUrlsSource urlsSource) : base(world, cache)
        {
            this.webRequestController = webRequestController;
            this.sceneFactory = sceneFactory;
            this.smartWearableCache = smartWearableCache;
            this.urlsSource = urlsSource;
        }

        protected override async UniTask<StreamableLoadingResult<GetSmartWearableSceneIntention.Result>> FlowInternalAsync(GetSmartWearableSceneIntention intention, StreamableLoadingState state, IPartitionComponent partition, CancellationToken ct)
        {
            IWearable wearable = intention.SmartWearable;

            (ISceneContent? sceneContent, SceneMetadata? sceneMetadata) = await smartWearableCache.GetCachedSceneInfoAsync(wearable, ct);
            if (ct.IsCancellationRequested) return new StreamableLoadingResult<GetSmartWearableSceneIntention.Result>();

            if (sceneContent == null)
            {
                return new StreamableLoadingResult<GetSmartWearableSceneIntention.Result>(
                    ReportCategory.WEARABLE,
                    new Exception($"sceneContent of {wearable.GetName()} is null"));
            }

            if (sceneMetadata == null)
            {
                return new StreamableLoadingResult<GetSmartWearableSceneIntention.Result>(
                    ReportCategory.WEARABLE,
                    new Exception($"sceneMetadata of {wearable.GetName()} is null"));
            }

            AssetBundleManifestVersion manifestVersion = wearable.DTO.assetBundleManifestVersion!;
            SceneEntityDefinition sceneDefinition = new SceneEntityDefinition(wearable.DTO.id!, sceneMetadata, manifestVersion);

            ReadOnlyMemory<byte> crdt = await GetCrdtAsync(sceneContent, ct);
            if (ct.IsCancellationRequested) return new StreamableLoadingResult<GetSmartWearableSceneIntention.Result>();

            var definitionComponent = SceneDefinitionComponentFactory.CreateFromDefinition(sceneDefinition, new IpfsPath(sceneDefinition.id!, URLDomain.FromString(urlsSource.Url(DecentralandUrl.Content))), true);

            var sceneData = new SceneData(
                sceneContent,
                sceneDefinition,
                sceneDefinition.metadata.scene.DecodedBase,
                definitionComponent.SceneGeometry,
                definitionComponent.Parcels,
                new StaticSceneMessages(crdt));

            // Set the flag is we are using the special DTO for builder collection preview
            sceneData.IsWearableBuilderCollectionPreview = wearable.DTO is BuilderWearableDTO;

            var requiredPermissions = sceneDefinition.metadata.requiredPermissions;
            var scenePermissions = new RestrictedJsApiPermissionsProvider(requiredPermissions);
            ISceneFacade? sceneFacade = await sceneFactory.CreateSceneFromSceneDefinition(sceneData, scenePermissions, partition, ct);
            if (ct.IsCancellationRequested) return new StreamableLoadingResult<GetSmartWearableSceneIntention.Result>();

            await UniTask.SwitchToMainThread();
            sceneFacade?.Initialize();

            ReportHub.Log(GetReportCategory(), $"Smart Wearable scene {SmartWearableCache.GetCacheId(wearable)} loaded");

            var result = new GetSmartWearableSceneIntention.Result
            {
                SceneDefinition = definitionComponent,
                SceneFacade = sceneFacade
            };
            return new StreamableLoadingResult<GetSmartWearableSceneIntention.Result>(result);
        }

        private async UniTask<ReadOnlyMemory<byte>> GetCrdtAsync(ISceneContent sceneContent, CancellationToken ct)
        {
            if (!sceneContent.TryGetContentUrl("main.crdt", out var url))
            {
                // We do not report any error since the 'main.crdt' file is not mandatory
                return ReadOnlyMemory<byte>.Empty;
            }

            return await webRequestController.GetAsync(new CommonArguments(url), ct, GetReportData()).GetDataCopyAsync();
        }
    }
}