SCR_WorkshopDownloadSequence.c

Go to the documentation of this file.

 
class SCR_WorkshopDownloadSequence : SCR_DownloadSequence
{   
    protected static float LOADING_DELAY = 500;
    
    protected ref SCR_WorkshopItem m_Item;
    protected ref Revision m_ItemTargetRevision;
 
    protected SCR_LoadingOverlayDialog m_LoadingOverlay;
    
    protected ref ScriptInvoker<> m_OnDownloadConfirmDisplayed = new ScriptInvoker<>();
    
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnDownloadConfirmDisplayed()
    {
        return m_OnDownloadConfirmDisplayed;
    }
    
    //------------------------------------------------------------------------------------------------
    // Public 
    //------------------------------------------------------------------------------------------------
    
    //------------------------------------------------------------------------------------------------
    static SCR_WorkshopDownloadSequence Create(SCR_WorkshopItem item, Revision itemTargetRevision, SCR_WorkshopDownloadSequence previous)
    {
        if (previous && previous.m_bWaitingResponse)
            return previous;
        
        SCR_WorkshopDownloadSequence sq = new SCR_WorkshopDownloadSequence(null, item, itemTargetRevision);
        
        return sq;
    }
    
    //------------------------------------------------------------------------------------------------
    protected void CreateLoadingOverlay()
    {
        // Skip if already loaded
        if (!m_bWaitingResponse)
            return;
        
        // Show only if we are still waiting for data
        m_LoadingOverlay = SCR_LoadingOverlayDialog.Create();
        m_LoadingOverlay.m_OnCloseStarted.Insert(Cancel); // Cancel this when the loading overlay close is initiated by user
    }
    
    //------------------------------------------------------------------------------------------------
    // Protected  
    //------------------------------------------------------------------------------------------------
    
    //------------------------------------------------------------------------------------------------
    override protected void AllPatchSizeLoaded()
    {
        // Setup callback and compute
        SCR_BackendCallbackWorkshopItem callback = new SCR_BackendCallbackWorkshopItem(m_Item);
        callback.GetEventOnResponse().Insert(OnItemPatchLoaded);
        m_aPatchSizeCallbacks.Insert(callback);
        
        m_ItemTargetRevision.ComputePatchSize(callback);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void HandleError()
    {
        if (m_bWaitingResponse || !m_bFailed)
        {
            if (m_LoadingOverlay)
                m_LoadingOverlay.CloseAnimated();
 
            // Add action to downloads
            SCR_WorkshopItemActionDownload action = new SCR_WorkshopItemActionDownload(m_Item, latestVersion: true);
            SCR_DownloadManager.GetInstance().AddDownloadManagerEntry(m_Item, action);
            action.Activate();
            
            // Display fail dialog in next frame to display it after action is really failed
            // TODO - improve logic and move to base
            if (!SCR_DownloadManager_Dialog.Cast(SCR_ConfigurableDialogUi.GetCurrentDialog()))
            {
                GetGame().GetCallqueue().CallLater(SetupAddonFail, 0, false, action);
            }
        }
        
        // Clear waiting
        m_bWaitingResponse = false;
        m_bFailed = true;
    }
    
    //------------------------------------------------------------------------------------------------
    protected void SetupAddonFail(SCR_WorkshopItemActionDownload action)
    {
        SCR_DownloadManager_Dialog.Create();
        //action.ForceFail();
    }
    
    //------------------------------------------------------------------------------------------------
    protected void ShowRestrictedItemDialog()
    {
        m_bWaitingResponse = false;
        
        // Close the loading overlay
        if (m_LoadingOverlay)
            m_LoadingOverlay.CloseAnimated(false);
        
        SCR_WorkshopUiCommon.CreateDialog("error_addon_blocked");
    }
    
    //------------------------------------------------------------------------------------------------
    protected void ShowConfirmationUI()
    {
        if (m_LoadingOverlay)
            m_LoadingOverlay.CloseAnimated();
        
        if (m_bRestrictedAddons)
            return;
        
        // Setup main item
        bool downloadMainItem = SCR_DownloadManager.IsLatestDownloadRequired(m_Item);
        
        // Get dependencies
        array<ref SCR_WorkshopItem> dependenciesToLoad = {};
        SCR_DownloadManager.SelectAddonsForLatestDownload(m_aDependencies, dependenciesToLoad);
        
        // Show confirmation only if there are dependencies
        if (!m_aDependencies.IsEmpty())
        {
            SCR_DownloadConfirmationDialog confirmDialog = SCR_DownloadConfirmationDialog.CreateForAddonAndDependencies(m_Item, downloadMainItem, dependenciesToLoad, m_bSubscribeToAddons);
            
            if (m_OnDownloadConfirmDisplayed)
                m_OnDownloadConfirmDisplayed.Invoke(this, confirmDialog);
        }
        else
        {
            // Start download immediately
            //SCR_DownloadManager.GetInstance().DownloadLatestWithDependencies(m_Item, downloadMainItem, dependenciesToLoad);
            SCR_DownloadManager.GetInstance().DownloadItems({m_Item});
            
            // Subscribe to items
            if (!m_bSubscribeToAddons)
                return;
            
            if (m_Item)
                m_Item.SetSubscribed(true);
            
            foreach (SCR_WorkshopItem dependency : dependenciesToLoad)
            {
                dependency.SetSubscribed(true);
            }
        }
    }
    
    //------------------------------------------------------------------------------------------------
    // Callbacks  
    //------------------------------------------------------------------------------------------------
    
    //------------------------------------------------------------------------------------------------
    override protected void OnItemError(SCR_WorkshopItem item)
    {
        HandleError();
        
        super.OnItemError(item);
    }
    
    //------------------------------------------------------------------------------------------------
    override protected void OnAllDependenciesDetailsLoaded()
    {
        // Close the loading overlay
        if (m_LoadingOverlay)
            m_LoadingOverlay.CloseAnimated(false);
        
        GetOnRestrictedDependency().Insert(OnRestrictedDependenciesFound);
        
        super.OnAllDependenciesDetailsLoaded();
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnRestrictedDependenciesFound(SCR_DownloadSequence sequence, array<ref SCR_WorkshopItem> dependencies)
    {
        ShowRestrictedDependenciesDialog();
        GetOnRestrictedDependency().Remove(OnRestrictedDependenciesFound);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnItemDependenciesLoaded(notnull SCR_WorkshopItem item)
    {   
        // Unsubscribe - this callback is not needed any more
        m_Item.m_OnDependenciesLoaded.Remove(OnItemDependenciesLoaded);
        
        m_aDependencies = m_Item.GetLatestDependencies();
        
        // Resticted 
        if (item.GetRestricted())
        {
            ShowRestrictedItemDialog();
            return;
        }
        
        // No dependencies
        if (m_aDependencies.IsEmpty())
        {
            OnAllDependenciesDetailsLoaded();
            return;
        }
        
        // Load
        //OnAllDependenciesDetailsLoaded();
        LoadDependenciesDetails();
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnItemGetAsset(SCR_WorkshopItem item)
    {
        if (!item.GetRequestFailed())
            return;
 
        GetGame().GetCallqueue().Remove(CreateLoadingOverlay);
        if (m_LoadingOverlay)
            m_LoadingOverlay.Close();
        
        OnItemError(item);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnItemPatchLoaded(SCR_BackendCallback callback = null)
    {
        // Error handling
        if (callback && callback.GetResponseType() == EBackendCallbackResponse.ERROR)
        {
            HandleError();
            return;
        }
        
        // Size 
        float size;
        m_ItemTargetRevision.GetPatchSize(size);
        m_Item.SetTargetRevisionPatchSize(size);
        
        // All ready
        m_bWaitingResponse = false;
        
        if (HasAllDetails())
        {           
            if (m_OnReady)
                m_OnReady.Invoke(this);
            
            ShowConfirmationUI();
        }
    }
    
    //------------------------------------------------------------------------------------------------
    // Construct  
    //------------------------------------------------------------------------------------------------
    
    //------------------------------------------------------------------------------------------------
    void SCR_WorkshopDownloadSequence(array<ref SCR_WorkshopItem> dependencies, SCR_WorkshopItem item, Revision itemTargetRevision)
    {
        // Setup
        m_Item = item;
        m_ItemTargetRevision = itemTargetRevision;
        m_Item.SetItemTargetRevision(itemTargetRevision);
        
        m_bWaitingResponse = true;
        
        // Load
        m_Item.m_OnDependenciesLoaded.Insert(OnItemDependenciesLoaded);
        
        m_Item.m_OnGetAsset.Insert(OnItemGetAsset);
        m_Item.m_OnError.Insert(OnItemError);
        m_Item.m_OnTimeout.Insert(OnItemError);
        
        m_Item.LoadDetails();
        
        GetGame().GetCallqueue().CallLater(CreateLoadingOverlay, LOADING_DELAY);
    }
    
    //------------------------------------------------------------------------------------------------
    void ~SCR_WorkshopDownloadSequence()
    {
        #ifdef WORKSHOP_DEBUG
        ContentBrowserUI._print(string.Format("SCR_WorkshopDownloadSequence: Delete for: %1", m_Item.GetName()));
        #endif
        
        if (m_LoadingOverlay)
            m_LoadingOverlay.Close();
        
        // Unsubscribe from item's events
        m_Item.m_OnDependenciesLoaded.Remove(OnItemDependenciesLoaded);
    }
};