private bool ShowLogIfTimeout(float progress, LoadBundlesTaskComponent loadBundlesTask, ICollection <SingleNode <AssetBundleLoadingComponent> > assetBundleLoading)
        {
            bool flag = true;

            if (progress != this.lastProgress)
            {
                this.lastUpdateTime = Time.realtimeSinceStartup;
            }
            else if ((Time.realtimeSinceStartup - this.lastUpdateTime) > PROGRESS_LOADING_TIMEOUT)
            {
                this.lastUpdateTime = Time.realtimeSinceStartup;
                Console.WriteLine("Timeout on tracked bundles loading");
                Console.WriteLine("Tracked bundles:");
                foreach (AssetBundleInfo info in loadBundlesTask.TrackedBundles)
                {
                    Console.WriteLine(info.Filename);
                }
                Console.WriteLine("ResourceLoadStats:");
                foreach (SingleNode <AssetBundleLoadingComponent> node in assetBundleLoading)
                {
                    Console.WriteLine("LoadingBundle: {0}, state: {1}", node.component.AssetBundleDiskCacheRequest.AssetBundleInfo, node.component.AssetBundleDiskCacheRequest.State);
                }
                flag = false;
            }
            this.lastProgress = progress;
            return(flag);
        }
        public void PrepareLoadTask(ProgressBarCalucationEvent e, ProgressBarNode node, [JoinAll] ICollection <AssetBundleNode> loadingBundles)
        {
            HashSet <AssetBundleInfo> trackedBundles = new HashSet <AssetBundleInfo>();

            foreach (AssetBundleNode node2 in loadingBundles)
            {
                foreach (AssetBundleInfo info in node2.assetBundlesLoadData.BundlesToLoad)
                {
                    if (!AssetBundlesStorage.IsStored(info))
                    {
                        trackedBundles.Add(info);
                    }
                }
                foreach (AssetBundleInfo info2 in node2.assetBundlesLoadData.LoadingBundles)
                {
                    if (!AssetBundlesStorage.IsStored(info2))
                    {
                        trackedBundles.Add(info2);
                    }
                }
            }
            LoadBundlesTaskComponent component = new LoadBundlesTaskComponent(trackedBundles);

            node.Entity.AddComponent(component);
        }
        private void CancelUnactualBundles(LoadBundlesTaskComponent loadBundlesTask, ICollection <SingleNode <ResourceLoadStatComponent> > loadStats)
        {
            HashSet <AssetBundleInfo> trackedBundles = loadBundlesTask.TrackedBundles;

            this.loadingBundles.Clear();
            this.canceledBundles.Clear();
            foreach (SingleNode <ResourceLoadStatComponent> node in loadStats)
            {
                foreach (AssetBundleInfo info in node.component.BundleToProgress.Keys)
                {
                    this.loadingBundles.Add(info);
                }
            }
            foreach (AssetBundleInfo info2 in trackedBundles)
            {
                if (!this.loadingBundles.Contains(info2))
                {
                    this.canceledBundles.Add(info2);
                }
            }
            foreach (AssetBundleInfo info3 in this.canceledBundles)
            {
                loadBundlesTask.CancelBundle(info3);
            }
        }
        public void UpdateProgress(UpdateEvent e, CalculatedProgressBarNode node, [JoinAll] ICollection <SingleNode <ResourceLoadStatComponent> > loadStats, [JoinAll] ICollection <SingleNode <AssetBundleLoadingComponent> > assetBundlesLoading)
        {
            LoadBundlesTaskComponent loadBundlesTask = node.loadBundlesTask;

            this.UpdateLoadBundlesTask(loadBundlesTask, loadStats);
            node.loadBundlesTaskProvider.UpdateData(loadBundlesTask);
            if (loadBundlesTask.AllBundlesLoaded())
            {
                base.Log.Info("ProgressComplete");
                node.Entity.RemoveComponent <LoadBundlesTaskComponent>();
                node.Entity.AddComponentIfAbsent <LoadProgressTaskCompleteComponent>();
            }
            else if (!node.Entity.HasComponent <LoadProgressTaskCompleteComponent>() && this.ShowLogIfTimeout(node.resourcesLoadProgressBar.ProgressBar.ProgressValue, loadBundlesTask, assetBundlesLoading))
            {
                base.Log.Info("LoadingComplete by timeout");
                node.Entity.AddComponent <LoadProgressTaskCompleteComponent>();
            }
        }
        private void UpdateLoadBundlesTask(LoadBundlesTaskComponent loadBundlesTask, ICollection <SingleNode <ResourceLoadStatComponent> > loadStats)
        {
            HashSet <AssetBundleInfo> trackedBundles = loadBundlesTask.TrackedBundles;

            foreach (AssetBundleInfo info in loadBundlesTask.TrackedBundles.ToArray <AssetBundleInfo>())
            {
                if (AssetBundlesStorage.IsStored(info))
                {
                    loadBundlesTask.MarkBundleAsLoaded(info);
                }
            }
            this.CancelUnactualBundles(loadBundlesTask, loadStats);
            foreach (SingleNode <ResourceLoadStatComponent> node in loadStats)
            {
                foreach (KeyValuePair <AssetBundleInfo, float> pair in node.component.BundleToProgress)
                {
                    AssetBundleInfo key = pair.Key;
                    if (trackedBundles.Contains(key))
                    {
                        loadBundlesTask.SetBundleProgressLoading(key, pair.Value);
                    }
                }
            }
        }
 private void OnDataChange(LoadBundlesTaskComponent loadBundlesTask)
 {
     this.progressBar.UpdateView(loadBundlesTask);
 }