SCR_AnalyticsApplication.c

Go to the documentation of this file.

[EnumLinear()]
enum SCR_EAnalyticalItemSlotType
{
    HORIZONTAL, // weapons, quick slots
    VERTICAL, // helmet, vest, bag, t-shirt, trausers, etc.
    CHARACTER_STORAGE, // actual items in vests, trausers, etc.
    VICINITY, // loot
    OTHER
}
 
/*
[EnumLinear()]
enum SCR_EAnalyticsWorkshopTab
{
    MODS,
    MAKE_ARMA_NOT_WAR,
    GAME_SAVES, 
    DOWNLOADED,
    MOD_MANAGER
}
 
[EnumBitFlag()]
enum SCR_EAnalyticsApplicationLoggingFlags
{
    CONSOLE,
    FILE,
    API
}
 
[EnumLinear()]
enum SCR_EAnalyticsDataTable
{
    APPLICATION,
    PLAYER,
    SESSION,
    MOD
}
 
enum SCR_EAnalyticsCourseEndReason : SCR_ETutorialBreakType
{
    COMPLETED
}
 
class SCR_AnalyticsApplication : WorldSystem
{
    protected static const string ANALYTICAL_EVENT_SETTINGS_CLOSED = "settingsClosed";
    protected ref SCR_SettingsTimeSpentData m_SettingsData = new SCR_SettingsTimeSpentData();
    protected ref SCR_AnalyticsSettings m_SettingsInteractions = new SCR_AnalyticsSettings();

    protected static const string ANALYTICAL_EVENT_SCENARIOS_MENU_CLOSE = "scenariosMenuClosed";
    protected ref SCR_MenuInteractedData m_ScenariosData = new SCR_MenuInteractedData();
    protected ref SCR_AnalyticsInteractions m_ScenariosInteractions = new SCR_AnalyticsInteractions();

    protected static const string ANALYTICAL_EVENT_WORKSHOP_CLOSED = "workshopMenuClosed";
    protected ref SCR_MenuInteractedData m_WorkshopData = new SCR_MenuInteractedData();
    protected ref SCR_AnalyticsInteractions m_WorkshopInteractions = new SCR_AnalyticsInteractions();
    
    // Mod Details
    protected static const string ANALYTICAL_EVENT_MOD_CLOSED = "modMenuClosed";
    protected ref SCR_MenuInteractedData m_ModData = new SCR_MenuInteractedData();
    protected ref SCR_AnalyticsInteractions m_ModInteractions = new SCR_AnalyticsInteractions();

    protected static const string ANALYTICAL_EVENT_PLAY_MENU_CLOSED = "playMenuClosed";
    protected ref SCR_AnalyticsInteractions m_PlayMenuInteractions = new SCR_AnalyticsInteractions();
    protected ref SCR_MenuTimeSpentData m_PlayMenuData = new SCR_MenuTimeSpentData();

    protected static const string ANALYTICAL_EVENT_MULTIPLAYER_MENU_CLOSED = "multiplayerMenuClosed";
    protected ref SCR_MenuInteractedData m_MultiplayerMenuData = new SCR_MenuInteractedData();
    protected ref SCR_AnalyticsInteractions m_MultiplayerMenuInteractions = new SCR_AnalyticsInteractions();

    protected static const string MANUAL_LOCATION_GAME = "Game";
    protected static const string MANUAL_LOCATION_MAIN_MENU = "Main Menu";
    protected static const string ANALYTICAL_EVENT_FIELD_MANUAL_CLOSED = "manualClosed";
    protected ref SCR_AnalyticsInteractions m_FieldManualInteractions = new SCR_AnalyticsInteractions();
    protected ref SCR_FieldManualTimeSpentData m_FieldManualData = new SCR_FieldManualTimeSpentData();

    protected static const string ANALYTICAL_EVENT_INVENTORY_CLOSED = "inventoryClosed";
    protected ref SCR_AnalyticsInventory m_Inventory = new SCR_AnalyticsInventory();
    protected ref SCR_InventoryData m_InventoryData = new SCR_InventoryData();
    protected SCR_EAnalyticalItemSlotType m_eLastInteractedStorage = SCR_EAnalyticalItemSlotType.OTHER;
    protected int m_iLastInteractedSlotId = 0;
    protected ResourceName m_sLastInteractedResource = "";
    protected static const ref array<EMenuAction> MOVING_MENU_ACTIONS
        = { EMenuAction.ACTION_MOVEBETWEEN, EMenuAction.ACTION_DRAGGED, EMenuAction.ACTION_DROPPED, EMenuAction.ACTION_MOVEINSIDE };

    protected static const string ANALYTICAL_EVENT_VOTE_ENDS = "voteEnd";
    protected ref SCR_VotingResultData m_VotingData = new SCR_VotingResultData();
    
    // MOB Selections
    protected ref SCR_MOBSelectedData m_MOBData = new SCR_MOBSelectedData();    
    protected static const string ANALYTICAL_EVENT_MOB_SELECTED = "MOBsSelected";
    
    protected static const string ANALYTICAL_EVENT_COURSE_ENDS = "courseEnd";
    protected ref SCR_CourseEndData m_CourseData = new SCR_CourseEndData();
    protected ref SCR_AnalyticsTimer m_CourseTimer = new SCR_AnalyticsTimer();
    protected SCR_ETutorialCourses m_StartedCourse = 0;
    
    protected SCR_EAnalyticsApplicationLoggingFlags m_Logging
                    = SCR_EAnalyticsApplicationLoggingFlags.CONSOLE
                        | SCR_EAnalyticsApplicationLoggingFlags.API;

    protected static const int LOCAL_PLAYER_ID = 8888;

    
    //------------------------------------------------------------------------------------------------
    void OpenPlayMenu()
    {
        m_PlayMenuInteractions.Start();
    }
    
    //------------------------------------------------------------------------------------------------
    void ClosePlayMenu()
    {
        m_PlayMenuInteractions.Close();
    }
    
    
    //------------------------------------------------------------------------------------------------
    void OpenFieldManual()
    {
        m_FieldManualInteractions.Start();
    }
    
    //------------------------------------------------------------------------------------------------
    void CloseFieldManual()
    {
        m_FieldManualInteractions.Close();
    }
    
 
    //------------------------------------------------------------------------------------------------
    void OpenSettings()
    {
        m_SettingsInteractions.Start();
    }
 
    //------------------------------------------------------------------------------------------------
    void CloseSettings()
    {
        m_SettingsData.amt_time_spent = m_SettingsInteractions.GetTimeSpent();
        m_SettingsData.array_settings_changed = m_SettingsInteractions.GetSettingsChanged();
        SendAnalyticalEvent(m_SettingsData, ANALYTICAL_EVENT_SETTINGS_CLOSED, SCR_EAnalyticsDataTable.APPLICATION);
    }
 
    //------------------------------------------------------------------------------------------------
    void SetQualityPresetSetting(int index)
    {
        m_SettingsInteractions.SetQualityPreset(index);
    }
 
    //------------------------------------------------------------------------------------------------
    void SetHudVisibilitySetting(int index)
    {
        m_SettingsInteractions.SetHudVisibility(index);
    }
 
    //------------------------------------------------------------------------------------------------
    void ChangeSetting(string category, string action)
    {
        m_SettingsInteractions.ChangeSetting(category, action);
    }
 
    //------------------------------------------------------------------------------------------------
    void ChangeKeybind(string action, string preset)
    {
        m_SettingsInteractions.ChangeSetting("Controls", string.Format("%1_%2", action, preset));
    }
 
    //------------------------------------------------------------------------------------------------
    void ResetAllKeybinds()
    {
        m_SettingsInteractions.UseResetAllButton();
    }

 
    //------------------------------------------------------------------------------------------------
    void OpenMultiplayerMenu()
    {
        m_MultiplayerMenuInteractions.Start();
    }
 
    //------------------------------------------------------------------------------------------------
    void CloseMultiplayerMenu()
    {
        m_MultiplayerMenuInteractions.Close();  
    }
 
    //------------------------------------------------------------------------------------------------
    void MultiplayerMenuSetTab(SCR_EServerBrowserTabs tab)
    {
        m_MultiplayerMenuInteractions.SetTab(typename.EnumToString(SCR_EServerBrowserTabs, tab));
    }
 
    //------------------------------------------------------------------------------------------------
    void MultiplayerMenuSetSorting(string sorting)
    {
        m_MultiplayerMenuInteractions.SetSorting(sorting);
    }
 
    //------------------------------------------------------------------------------------------------
    void MultiplayerMenuSetFilter(string filterCategory, string filterName)
    {
        m_MultiplayerMenuInteractions.SetFilter(filterCategory, filterName);
    }
 
    //------------------------------------------------------------------------------------------------
    void MultiplayerMenuUseSearch()
    {
        m_MultiplayerMenuInteractions.UseSearch();
    }
 
    //------------------------------------------------------------------------------------------------
    void MultiplayerMenuUseFavorite()
    {
        m_MultiplayerMenuInteractions.UseFavorite();
    }
 
    //------------------------------------------------------------------------------------------------
    void MultiplayerMenuUseFilterOn()
    {
        m_MultiplayerMenuInteractions.UseFilterOn();
    }

 
    //------------------------------------------------------------------------------------------------
    void OpenWorkshop()
    {
        m_WorkshopInteractions.Start();
    }
 
    //------------------------------------------------------------------------------------------------
    void CloseWorkshop()
    {
        m_WorkshopInteractions.Close();
    }
    
    //------------------------------------------------------------------------------------------------
    void WorkshopSetTab(SCR_EAnalyticsWorkshopTab tab)
    {
        m_WorkshopInteractions.SetTab(typename.EnumToString(SCR_EAnalyticsWorkshopTab, tab));
    }
 
    //------------------------------------------------------------------------------------------------
    void WorkshopSetSorting(string sorting)
    {
        m_WorkshopInteractions.SetSorting(sorting);
    }
 
    //------------------------------------------------------------------------------------------------
    void WorkshopSetFilter(string filterCategory, string filterName)
    {
        m_WorkshopInteractions.SetFilter(filterCategory, filterName);
    }
 
    //------------------------------------------------------------------------------------------------
    void WorkshopUseSearch()
    {
        m_WorkshopInteractions.UseSearch();
    }
 
    //------------------------------------------------------------------------------------------------
    void WorkshopUseFilterOn()
    {
        m_WorkshopInteractions.UseFilterOn();
    }
    
 
    //------------------------------------------------------------------------------------------------
    void OpenModDetails()
    {
        m_ModInteractions.Start();
    }
    
    //------------------------------------------------------------------------------------------------
    void CloseModDetails()
    {
        m_ModInteractions.Close();
    }
 
    //------------------------------------------------------------------------------------------------
    void ModDetailsSetTab(SCR_EModDetailsMenuTabs tab)
    {
        m_ModInteractions.SetTab(typename.EnumToString(SCR_EModDetailsMenuTabs, tab));
    }

 
    //------------------------------------------------------------------------------------------------
    void OpenScenarios()
    {
        m_ScenariosInteractions.Start();
    }
 
    //------------------------------------------------------------------------------------------------
    void CloseScenarios()
    {
        m_ScenariosInteractions.Close();
    }
 
    //------------------------------------------------------------------------------------------------
    void ScenariosSetTab(EScenarioSubMenuMode tab)
    {
        m_ScenariosInteractions.SetTab(typename.EnumToString(EScenarioSubMenuMode, tab));
    }
 
    //------------------------------------------------------------------------------------------------
    void ScenariosSetSorting(string sorting)
    {
        m_ScenariosInteractions.SetSorting(sorting);
    }
 
    //------------------------------------------------------------------------------------------------
    void ScenariosUseSearch()
    {
        m_ScenariosInteractions.UseSearch();
    }
    
    
    //------------------------------------------------------------------------------------------------
    void OpenInventory(float currentWeight)
    {       
        m_Inventory.OpenInventory(currentWeight);
    }
    
    //------------------------------------------------------------------------------------------------
    void CloseInventory(float currentWeight)
    {
        m_Inventory.CloseInventory(currentWeight);
    }
    
    //------------------------------------------------------------------------------------------------
    void InteractWithItem(SCR_InventorySlotUI focusedItem, SCR_InventorySlotUI selectedItem, EMenuAction action, bool isUsingGamepad)
    {
        // interaction is any move action or item selection on controller
        bool isInteraction = MOVING_MENU_ACTIONS.Contains(action) || (action == EMenuAction.ACTION_SELECT && isUsingGamepad);       
        if ((!focusedItem && !selectedItem) || !isInteraction)
            return;
        
        SCR_InventorySlotUI currentItem;
        if (focusedItem)
            currentItem = focusedItem;
        else
            currentItem = selectedItem;
        
        // prevent spamming interactions with the same items
        if (m_eLastInteractedStorage == currentItem.GetAnalyticalItemSlotType() 
            && m_iLastInteractedSlotId == currentItem.GetStorageUI().GetSlotId(currentItem)
            && m_sLastInteractedResource == currentItem.GetItemResource())
            return;
        
        m_eLastInteractedStorage = currentItem.GetAnalyticalItemSlotType();
        m_iLastInteractedSlotId = currentItem.GetStorageUI().GetSlotId(currentItem);
        m_sLastInteractedResource = currentItem.GetItemResource();
        
        m_Inventory.InteractWithItem(m_eLastInteractedStorage);
    }
 
    //------------------------------------------------------------------------------------------------
    void UseHealingFromInventory()
    {
        m_Inventory.UseHealing();
    }
 
    //------------------------------------------------------------------------------------------------
    void UseExaminationFromInventory()
    {
        m_Inventory.UseExamination();
    }
    
    
    //------------------------------------------------------------------------------------------------
    void VoteToKickResult(EVotingType voteType, string author_id, string vote_winner_id, bool result)
    {
        m_VotingData.vote_type = typename.EnumToString(EVotingType, voteType);
        m_VotingData.vote_author_id = author_id;
        m_VotingData.vote_winner_id = vote_winner_id;
        m_VotingData.flag_vote_success = result;
        SendAnalyticalEvent(m_VotingData, ANALYTICAL_EVENT_VOTE_ENDS, SCR_EAnalyticsDataTable.SESSION);
    }
    
    //------------------------------------------------------------------------------------------------
    void OnMOBSelected(array<SCR_CampaignMilitaryBaseComponent> selectedHQs)
    {           
        m_MOBData.MOB_names = "[";
        m_MOBData.MOB_factions = "[";
        m_MOBData.MOB_xs = "["; 
        m_MOBData.MOB_ys = "["; 
        m_MOBData.MOB_zs = "["; 
        
        foreach(int i, SCR_CampaignMilitaryBaseComponent selectedHQ : selectedHQs)
        {
            
            if(i != 0)
            {
                m_MOBData.MOB_names += ", ";
                m_MOBData.MOB_factions += ", ";
                m_MOBData.MOB_xs += ", ";
                m_MOBData.MOB_ys += ", "; 
                m_MOBData.MOB_zs += ", "; 
            }
            
            m_MOBData.MOB_names += selectedHQ.GetBaseNameUpperCase();
            m_MOBData.MOB_factions += selectedHQ.GetFaction().GetFactionName();
            m_MOBData.MOB_xs += selectedHQ.GetOwner().GetOrigin()[0].ToString(); 
            m_MOBData.MOB_ys += selectedHQ.GetOwner().GetOrigin()[1].ToString();
            m_MOBData.MOB_zs += selectedHQ.GetOwner().GetOrigin()[2].ToString();
            
            PrintString(selectedHQ.GetBaseNameUpperCase());
        }
        
        m_MOBData.MOB_names += "]";
        m_MOBData.MOB_factions += "]";
        m_MOBData.MOB_xs += "]";
        m_MOBData.MOB_ys += "]"; 
        m_MOBData.MOB_zs += "]";
        
        // We call this with a delay because the initialization is too early for the server to start
        GetGame().GetCallqueue().CallLater(SendMOBSessionEvent, 60000, false, m_MOBData); // a minute
    }
    
    //------------------------------------------------------------------------------------------------
    void SendMOBSessionEvent(SCR_MOBSelectedData mobData)
    {       
        SendAnalyticalEvent(mobData, ANALYTICAL_EVENT_MOB_SELECTED, SCR_EAnalyticsDataTable.SESSION);
    }   
    
    
    //------------------------------------------------------------------------------------------------
    void TutorialCourseStarts(SCR_ETutorialCourses course)
    {
        m_StartedCourse = course;
        m_CourseTimer.Start();
    }
    
    //------------------------------------------------------------------------------------------------
    void TutorialCourseEnds(SCR_ETutorialCourses course, SCR_EAnalyticsCourseEndReason reason)
    {       
        if (course != m_StartedCourse)
        {
            Debug.Error(
                string.Format("Can't send course end to analytics, as course which ended (%1) is not equal to course that was started (%2)!", course, m_StartedCourse)
            );
            return;
        }
 
        m_StartedCourse = 0;  // reset to prevent multiple same sends
        m_CourseData.amt_time_spent = m_CourseTimer.GetTimeSpent();
        m_CourseData.amt_course_name = typename.EnumToString(SCR_ETutorialCourses, course);
        m_CourseData.amt_course_end_reason = typename.EnumToString(SCR_EAnalyticsCourseEndReason, reason);      
        SendAnalyticalEvent(m_CourseData, ANALYTICAL_EVENT_COURSE_ENDS, SCR_EAnalyticsDataTable.PLAYER);
    }
    
 
    //------------------------------------------------------------------------------------------------
    void SetLogging(SCR_EAnalyticsApplicationLoggingFlags logging)
    {
        m_Logging = logging;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_EAnalyticsApplicationLoggingFlags GetLogging()
    {
        return m_Logging;
    }

 
    //------------------------------------------------------------------------------------------------
    static SCR_AnalyticsApplication GetInstance()
    {
        World world = GetGame().GetWorld();
        if (!world)
            return null;
 
        return SCR_AnalyticsApplication.Cast(world.FindSystem(SCR_AnalyticsApplication));
    }
 
    //------------------------------------------------------------------------------------------------
    override static void InitInfo(WorldSystemInfo outInfo)
    {
        outInfo.SetAbstract(false);
        outInfo.SetLocation(WorldSystemLocation.Both);
        outInfo.AddPoint(WorldSystemPoint.Frame);
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnUpdatePoint(WorldUpdatePointArgs args)
    {
        super.OnUpdatePoint(args);
        
        float deltaSeconds = args.GetTimeSliceSeconds();        
        UpdateData(m_ScenariosInteractions, m_ScenariosData, ANALYTICAL_EVENT_SCENARIOS_MENU_CLOSE, deltaSeconds);
        UpdateData(m_WorkshopInteractions, m_WorkshopData, ANALYTICAL_EVENT_WORKSHOP_CLOSED, deltaSeconds);
        UpdateData(m_MultiplayerMenuInteractions, m_MultiplayerMenuData, ANALYTICAL_EVENT_MULTIPLAYER_MENU_CLOSED, deltaSeconds);
        UpdateData(m_ModInteractions, m_ModData, ANALYTICAL_EVENT_MOD_CLOSED, deltaSeconds);        
        UpdateInventory(deltaSeconds);
        UpdatePlayMenu(deltaSeconds);
        UpdateFieldManual(deltaSeconds);
    }
    
    
    //------------------------------------------------------------------------------------------------
    protected void UpdateData(SCR_AnalyticsInteractions interactions, SCR_MenuInteractedData data, string analytical_event, float deltaSeconds)
    {
        interactions.Update(deltaSeconds);
        if (interactions.IsReadyToSend())
        {
            data.amt_time_spent = interactions.GetTimeSpent();
            data.array_menu_interactions = interactions.GetInteractions();
            data.cnt_menu_reopen = interactions.GetReopenTimes();
            SendAnalyticalEvent(data, analytical_event, SCR_EAnalyticsDataTable.APPLICATION);
            interactions.ResetReadyToSend();
        }       
    }
    
    //------------------------------------------------------------------------------------------------
    protected void UpdateInventory(float deltaSeconds)
    {
        m_Inventory.Update(deltaSeconds);
        if (m_Inventory.IsReadyToSend())
        {
            m_InventoryData = m_Inventory.GetClonedData();
            SendAnalyticalEvent(m_InventoryData, ANALYTICAL_EVENT_INVENTORY_CLOSED, SCR_EAnalyticsDataTable.PLAYER);
            m_Inventory.ResetReadyToSend();
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected void UpdatePlayMenu(float deltaSeconds)
    {       
        m_PlayMenuInteractions.Update(deltaSeconds);
        if (m_PlayMenuInteractions.IsReadyToSend())
        {
            m_PlayMenuData.amt_time_spent = m_PlayMenuInteractions.GetTimeSpent();
            m_PlayMenuData.cnt_menu_reopen = m_PlayMenuInteractions.GetReopenTimes();
            SendAnalyticalEvent(m_PlayMenuData, ANALYTICAL_EVENT_PLAY_MENU_CLOSED, SCR_EAnalyticsDataTable.APPLICATION);
            m_PlayMenuInteractions.ResetReadyToSend();
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected void UpdateFieldManual(float deltaSeconds)
    {       
        m_FieldManualInteractions.Update(deltaSeconds);
        if (m_FieldManualInteractions.IsReadyToSend())
        {
            m_FieldManualData.amt_time_spent = m_FieldManualInteractions.GetTimeSpent();
            m_FieldManualData.cnt_menu_reopen = m_FieldManualInteractions.GetReopenTimes();
            if (GetGame().m_bIsMainMenuOpen)
                m_FieldManualData.amt_name_location = MANUAL_LOCATION_MAIN_MENU;
            else
                m_FieldManualData.amt_name_location = MANUAL_LOCATION_GAME;
            SendAnalyticalEvent(m_FieldManualData, ANALYTICAL_EVENT_FIELD_MANUAL_CLOSED, SCR_EAnalyticsDataTable.APPLICATION);      
            m_FieldManualInteractions.ResetReadyToSend();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected void SendAnalyticalEvent(SCR_AnalyticsData object, string eventName, SCR_EAnalyticsDataTable dataTable)
    {
        string logString = string.Format("%1 %2: %3", SCR_DateTimeHelper.GetDateTimeUTC(), eventName, object.ToPrettyString());
 
        if (SCR_Enum.HasFlag(m_Logging, SCR_EAnalyticsApplicationLoggingFlags.CONSOLE))
            PrintFormat("%1", logString);
 
        if (SCR_Enum.HasFlag(m_Logging, SCR_EAnalyticsApplicationLoggingFlags.FILE))
        {
            // Open file for every write separately. If we would open it only once, then we would lose it after a crash or a hard kill.
            FileHandle analyticsFile = FileIO.OpenFile("$profile:analytics_uniform.txt", FileMode.APPEND);
            if (analyticsFile)
            {
                analyticsFile.WriteLine(logString);
                analyticsFile.Close();
            }
        }
 
        if (SCR_Enum.HasFlag(m_Logging, SCR_EAnalyticsApplicationLoggingFlags.API))
        {
            switch (dataTable)
            {
                case SCR_EAnalyticsDataTable.APPLICATION:
                    GetGame().GetStatsApi().CreateApplicationEvent(object, eventName);
                    break;
 
                case SCR_EAnalyticsDataTable.PLAYER:
                    GetGame().GetStatsApi().CreatePlayerEvent(LOCAL_PLAYER_ID, object, eventName, false);
                    break;
 
                case SCR_EAnalyticsDataTable.SESSION:
                    GetGame().GetStatsApi().CreateSessionEvent(object, eventName);
                    break;
 
                case SCR_EAnalyticsDataTable.MOD:
                    GetGame().GetStatsApi().CreateModEvent(object, eventName);
                    break;
 
                default:
                    Debug.Error(string.Format("Unrecognised SCR_EAnalyticsDataTable.%1! Please include it in 'SendAnalyticalEvent()'.", typename.EnumToString(SCR_EAnalyticsDataTable, dataTable)));
                    break;
            }
        }
    }
}
 
*/