# Show loading if data is loading

By monitoring the events from the Fetch Data, I can determine when the data is in the process of loading and when it's not. Utilizing these events, I display the loading status as follows:

<figure><img src="https://3467764585-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F4ujLeyUb7fFQKDxNyJFC%2Fuploads%2FlznNzkGPQGEy6HcV5Sa4%2FUntitledvideo-MadewithClipchamp-ezgif.com-video-to-gif-converter.gif?alt=media&#x26;token=8e1507af-e8a2-4c1f-a521-22579e454cb0" alt=""><figcaption></figcaption></figure>

In simple terms, I verify if the data is loading and then initiate a loading process using the Memory Pool of FSLoading. Here's how it works:

```csharp
/// <summary>
/// Pool for the loading
/// </summary>
public class FSLoadingPool
{
    private FSLoading.Pool _pool;

    /// <summary>
    /// Constructor and Memory Pool is passed as an argument to cache
    /// </summary>
    /// <param name="pool">Pool to use</param>
    public FSLoadingPool(FSLoading.Pool pool)
    {
        _pool = pool;
    }

    /// <summary>
    /// Calls when need to spawn FS Loading
    /// </summary>
    /// <param name="parent">what is the parent of this UI element</param>
    /// <returns>the reference of the loading</returns>
    public FSLoading Spawn(Transform parent)
    {
        return _pool.Spawn(parent);
    }

    /// <summary>
    /// Calls when need to remove or despawn
    /// </summary>
    /// <param name="loading">item to despawn</param>
    public void Remove(FSLoading loading)
    {
        _pool.Despawn(loading);
    }
}
```

This refers to the loading pool. I've attached a script to the loading prefabs, which serves to provide a UI reference and update the UI based on the data. The parent of the Loading is passed as an argument during the spawn process, as shown below:

```csharp
/// <summary>
/// Class component attach to the prefab of loading
/// </summary>
public class FSLoading : MonoBehaviour
{
    /// <summary>
    /// Text to show on the loading
    /// </summary>
    [SerializeField]
    private TextMeshProUGUI _title;
    /// <summary>
    /// % of loading done in this process
    /// </summary>
    [SerializeField]
    private TextMeshProUGUI _progress;

    /// <summary>
    /// The image fillamount on the loading
    /// </summary>
    [SerializeField]
    private Image _fill;

    /// <summary>
    /// Calls when the loading prefab is spawned
    /// </summary>
    /// <param name="parent">parent to be of this object</param>
    public void Setup(Transform parent)
    {
        RectTransform transform = GetComponent<RectTransform>();
        transform.parent = parent;
        transform.localPosition = Vector3.zero;
        transform.offsetMin = Vector2.zero;
        transform.offsetMax = Vector2.zero;
    }

    /// <summary>
    /// Calls when need to update the loading
    /// </summary>
    /// <param name="progress">value of the progress from 0 - 1</param>
    /// <param name="info">text information of the loading / like what is loading can be different text</param>
    public void ShowProgress(float progress, string info)
    {
        _fill.fillAmount = progress;
        _progress.text = string.Format("{0} %", (int)(progress * 100.00));
        _title.text = info;
    }

    /// <summary>
    /// Pool of the Loading
    /// </summary>
    public class Pool : MonoMemoryPool<Transform, FSLoading>
    {
        /// <summary>
        /// Calls on the initialize of the item initialize
        /// </summary>
        /// <param name="p1">parent to be</param>
        /// <param name="item">item spawned</param>
        protected override void Reinitialize(Transform p1, FSLoading item)
        {
            base.Reinitialize(p1, item);
            item.Setup(p1);
        }
    }
}
```

Following that, I generate a few instances in the pool using the Zenject code, as shown below:

```csharp
/// <summary>
/// Zenject Installer attach to the scene context
/// </summary>
public class FSLoadingInstaller : MonoInstaller
{
    /// <summary>
    /// Loading to spawn
    /// </summary>
    public GameObject _loader;

    public override void InstallBindings()
    {
        // binding the pool
        Container.Bind<FSLoadingPool>().AsSingle();
        // spawning item from the pool
        Container.BindMemoryPool<FSLoading, FSLoading.Pool>().WithInitialSize(1).FromComponentInNewPrefab(_loader).UnderTransformGroup("FSLoading");
    }
}
```

The memory pool has been prepared and is now available. I can initiate it as required in the following manner:

```csharp
_loaderPool.Spawn(loaderParent);
```

The complete script is now configured for retrieval as shown below:

```csharp
/// <summary>
/// Attach on the parent of the event
/// </summary>
public class EventDataUI : MonoBehaviour
{
    /// <summary>
    /// Data to load from the URL
    /// </summary>
    [SerializeField]
    private string url = "https://script.google.com/macros/s/AKfycbxHLP8yjErEQhU-BLTMJE6i0MllRpEPF2qTcVx0xNoe7Ur34dPqIG8bh4ay3CwUoQL4/exec";

    /// <summary>
    /// Fetch Data of the Event Injected object
    /// </summary>
    [Inject]
    private IFetchData<List<EventsData>> _fetchData;
    /// <summary>
    /// Pool of the loading
    /// </summary>
    [Inject]
    private FSLoadingPool _loaderPool;

    /// <summary>
    /// Cache the event data in this variable
    /// </summary>
    [SerializeField]
    private List<EventsData> _eventsData;

    /// <summary>
    /// FS loading parent
    /// </summary>
    [SerializeField]
    private Transform loaderParent;

    /// <summary>
    /// Spawned FSLoader reference
    /// </summary>
    private FSLoading loader;
    /// <summary>
    /// Loading status of the data
    /// </summary>
    private LoadingStatus _loadStatus;
    /// <summary>
    /// Message to show on the FS Loading
    /// </summary>
    private string _message = "Loading Events Data.";

    private void Awake()
    {
        // Fetch Data and wait till it's downloaded
        StartCoroutine(_fetchData.FetchData(url, OnProgress, OnCompleted));
    }

    private void OnEnable()
    {
        // Update load status
        if (_loadStatus == LoadingStatus.InProgress)
        {
            loader = _loaderPool.Spawn(loaderParent);
            // Update message while loading
            DOTween.To(() => _message, x => _message = x, _message + "...", 2).SetLoops(10);
        }
    }

    /// <summary>
    /// Calls when the data loading is in progress
    /// </summary>
    /// <param name="progress">progress of the laoding 0 - 1</param>
    /// <param name="info">message to display on the progress</param>
    void OnProgress(float progress, string info)
    {
        _loadStatus = LoadingStatus.InProgress;
        if (loader)
            loader.ShowProgress(progress, _message);
    }

    /// <summary>
    /// Calls when data is laoded
    /// </summary>
    /// <param name="isDone">is it completed or fail</param>
    /// <param name="data">output data</param>
    void OnCompleted(bool isDone, List<EventsData> data)
    {
        _loadStatus = isDone ? LoadingStatus.Completed : LoadingStatus.Fail;

        if (!isDone)
            return;

        _eventsData = data;
        // order downloaded data by the event type
        // active at top, coming soon at second and expired at below
        _eventsData = _eventsData.OrderBy(x => (int)x.EventType).ToList();
        // run for every item
        _eventsData.ForEach(item =>
        {
            // initialize item
            item.Init();
            // spawn items prefab here
        });

        if (loader)
            _loaderPool.Remove(loader);
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://muhammad-taha-bin-farooq.gitbook.io/sheet-linker/fetch-in-unity/ugui/show-loading-if-data-is-loading.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.