create and store context for the level event

Author: dorin-ga

include/GameAnalytics/GameAnalytics.h

@@ -77,7 +77,18 @@ namespace gameanalytics
 
          static void addErrorEvent(EGAErrorSeverity severity, std::string const& message, std::string const& customFields = "", bool mergeFields = false);
 
-         static void addLevelEvent(EGALevelStatus status, int levelId, std::string const& levelName, int value = 0, std::string const& customFields);
+         /// level event
+
+         static bool isLevelCurrentlyTracked();
+
+         static void addLevelStartEvent(int levelId, std::string const& levelName, int value = 0, std::string const& customFields = "");
+         static void addLevelAbortEvent(int value = 0, std::string const& customFields = "");
+         static void addLevelFailureEvent(int value = 0, std::string const& customFields = "");
+         static void addLevelCompleteEvent(int value = 0, std::string const& customFields = "");
+
+         static void addLevelEvent(EGALevelStatus status, int levelId, std::string const& levelName, int value = 0, std::string const& customFields = "");
+
+         //////////////////////
 
          // set calls can be changed at any time (pre- and post-initialize)
          // some calls only work after a configure is called (setCustomDimension)

source/gameanalytics/GAEvents.cpp

@@ -482,11 +482,7 @@ namespace gameanalytics
                     return;
                 }
 
-                if(!state::GAState::getInstance().updateLevelContext(status, id, name))
-                {
-                    logging::GALogger::e("Invalid level");
-                    return;
-                }
+                state::GAState& state = state::GAState::getInstance();
 
                 // Validate
                 validators::ValidationResult validationResult = validators::GAValidator::validateLevelEvent(status, id, name);
@@ -499,12 +495,18 @@ namespace gameanalytics
 
                 // Create empty eventData
                 json eventData;
+
                 eventData["category"]   = GAEvents::CategoryLevel;
                 eventData["status"]     = levelStatusString(status);
-                eventData["level_id"]   = id;
-                eventData["level_name"] = name;
                 eventData["value"]      = value;
 
+                if (status == EGALevelStatus::Start)
+                {
+                    eventData["level_id"]   = id;
+                    eventData["level_name"] = name;
+                    eventData["level_time"] = 0;
+                }
+
                 json cleanedFields = state::GAState::getValidatedCustomFields(fields);
                 getInstance().addCustomFieldsToEvent(eventData, cleanedFields);
 
@@ -516,6 +518,12 @@ namespace gameanalytics
 
                 // Send to store
                 getInstance().addEventToStore(eventData);
+
+                if (!state.updateLevelContext(status, id, name))
+                {
+                    logging::GALogger::e("Failed to update the level context with status:", levelStatusString(status));
+                    return;
+                }
             }
             catch(std::exception& e)
             {
@@ -925,6 +933,23 @@ namespace gameanalytics
             }
         }
 
+        std::string GAEvents::levelStatusString(EGALevelStatus lvlStatus)
+        {
+            switch (lvlStatus)
+            {
+                case EGALevelStatus::Start:
+                    return "start";
+                case EGALevelStatus::Abort:
+                    return "abort";
+                case EGALevelStatus::Complete:
+                    return "complete";
+                case EGALevelStatus::Failure:
+                    return "failure";
+                default:
+                    return "";
+            }
+        }
+
         void GAEvents::addSDKInitEvent()
         {
             try

source/gameanalytics/GALogger.h

@@ -26,7 +26,7 @@ namespace gameanalytics
                     return;
                 }
 
-                std::string tag = getInstance().tag;
+                std::string tag = getInstance().TAG;
                 tag += " :";
 
                 switch (logType)

source/gameanalytics/GAState.cpp

@@ -27,35 +27,90 @@ namespace gameanalytics
 
     namespace state
     {
-        bool GAState::LevelContext::StartLevel(int32_t id, std::string const& name)
+        bool GAState::LevelContext::startLevel(int32_t id, std::string const& name)
         {
-            if(!IsInLevel() && id > 0)
+            if(!isInLevel() && id > INVALID_LVL)
             {
+                logging::GALogger::d("Starting level %d with name %s", id, name.c_str());
+
                 levelId = id;
                 levelName = name;
 
                 timer.reset();
                 timer.start();
 
+                cachedTime = 0;
+                wasContextResumed = false;
+
                 return true;
             }
 
             return false;
         }
 
-        bool GAState::LevelContext::EndLevel()
+        bool GAState::LevelContext::endLevel()
         {
-            if(IsInLevel())
+            if(isInLevel())
             {
+                logging::GALogger::d("Ending level %d with name %s, total duration of %I64d seconds", levelId, levelName.c_str(), getLevelTime());
+
                 levelId = INVALID_LVL;
                 levelName = "";
+                cachedTime = 0;
+                wasContextResumed = false;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        bool GAState::LevelContext::resumeLevel(int32_t id, std::string const& name, int64_t timeElapsed)
+        {
+            if (startLevel(id, name))
+            {
+                logging::GALogger::d("Resumed cached level %d with name %s, total duration of %I64d seconds", levelId, levelName.c_str(), timeElapsed);
+
+                cachedTime = timeElapsed;
+                wasContextResumed = true;
+
+                return true;
+            }
+
+            return false;
+        }
 
+        bool GAState::LevelContext::resumeLevel()
+        {
+            if (isInLevel())
+            {
+                logging::GALogger::d("Resuming level %d with name %s, total duration of %I64d seconds", levelId, levelName.c_str(), getLevelTime());
+
+                timer.start();
                 return true;
             }
 
             return false;
         }
 
+        bool GAState::LevelContext::pauseLevel()
+        {
+            if (isInLevel())
+            {
+                logging::GALogger::d("Paused level %d with name %s, total duration of %I64d seconds", levelId, levelName.c_str(), getLevelTime());
+
+                timer.stop();
+                return true;
+            }
+
+            return false;
+        }
+
+        int64_t GAState::LevelContext::getLevelTime() const
+        {
+            return timer.getSeconds() + cachedTime;
+        }
+
         GAState& GAState::getInstance()
         {
             static GAState instance;
@@ -416,6 +471,11 @@ namespace gameanalytics
                     events::GAEvents::addHealthEvent();
                     events::GAEvents::addSessionEndEvent();
                     getInstance()._sessionStart = 0;
+
+                    if (getInstance()._levelContext.isInLevel())
+                    {
+                        getInstance().cacheLevelContext();
+                    }
                 }
                 events::GAEvents::stopEventQueue();
             }
@@ -458,10 +518,11 @@ namespace gameanalytics
                 // ---- OPTIONAL ---- //
 
                 // level
-                if(getInstance()._levelContext.IsInLevel())
+                if(getInstance()._levelContext.isInLevel())
                 {
                     out["level_name"] = getInstance()._levelContext.levelName;
                     out["level_id"]   = getInstance()._levelContext.levelId;
+                    out["level_time"] = getInstance()._levelContext.getLevelTime();
                 }
 
                 // A/B testing
@@ -668,6 +729,12 @@ namespace gameanalytics
                         }
                     }
                 }
+
+                if (checkCachedLevelContext(state_dict))
+                {
+                    logging::GALogger::d("Found active level attempt.");
+                    restoreLevelContext(state_dict);
+                }
             }
             catch (json::exception& e)
             {
@@ -835,7 +902,7 @@ namespace gameanalytics
                 // Set session start
                 _sessionStart = getClientTsAdjusted();
 
-                // to acurrately measure time
+                // to accurately measure time
                 _startTimepoint = std::chrono::high_resolution_clock::now();
 
                 // Add session start event
@@ -898,6 +965,11 @@ namespace gameanalytics
             return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::high_resolution_clock::now() - _startTimepoint).count();
         }
 
+        bool GAState::isLevelTracked() const
+        {
+            return _levelContext.isInLevel();
+        }
+
         void GAState::addRemoteConfigsListener(const std::shared_ptr<IRemoteConfigsListener>& listener)
         {
             if(std::find(getInstance()._remoteConfigsListeners.begin(), getInstance()._remoteConfigsListeners.end(), listener) == getInstance()._remoteConfigsListeners.end())
@@ -1176,27 +1248,85 @@ namespace gameanalytics
             {
                 case EGALevelStatus::Start:
                 {
-                    if(_levelContext.IsInLevel())
+                    if(_levelContext.isInLevel())
                     {
-                        
+                        logging::GALogger::w("A level is already active. Please call a level abort/failure/complete first!");
+                        return false;
                     }
 
-                    return _levelContext.StartLevel(id, levelName);
+                    return _levelContext.startLevel(id, levelName);
                 }
 
                 case EGALevelStatus::Failure:
                 case EGALevelStatus::Complete:
                 case EGALevelStatus::Abort:
                 {
-                    if(!_levelContext.IsInLevel())
+                    if(!_levelContext.isInLevel())
                     {
                         logging::GALogger::w("No active level found. A level start event must be called before Failure/Complete/Abort events!");
                         return false;
                     }
 
-                    return _levelContext.EndLevel();
+                    if (_levelContext.endLevel())
+                    {
+                        resetCachedLevelContext();
+                        return true;
+                    }
+                }
+            }
+        }
+
+        bool GAState::cacheLevelContext()
+        {
+            if (_levelContext.isInLevel())
+            {
+                logging::GALogger::d("Level is active. Caching level context.");
+
+                _gaStore.setState("level_id", std::to_string(_levelContext.levelId));
+                _gaStore.setState("level_name", _levelContext.levelName);
+                _gaStore.setState("level_time", std::to_string(_levelContext.getLevelTime()));
+
+                return true;
+            }
+
+            return false;
+        }
+
+        void GAState::resetCachedLevelContext()
+        {
+            // clear level context state
+            _gaStore.setState("level_id", "-1");
+            _gaStore.setState("level_name", "");
+            _gaStore.setState("level_time", "0");
+        }
+
+        bool GAState::restoreLevelContext(json& stateDict)
+        {
+            if (!_levelContext.isInLevel())
+            {
+                int32_t     levelId   = utilities::getNumberFromCache(stateDict, "level_id", LevelContext::INVALID_LVL);
+                int64_t     levelTime = utilities::getNumberFromCache(stateDict, "level_time", 0);
+                std::string levelName = utilities::getOptionalValue<std::string>(stateDict, "level_name", "");
+
+                if (levelId > LevelContext::INVALID_LVL)
+                {
+                    logging::GALogger::d("Restoring level context from local cache.");
+
+                    _levelContext.resumeLevel(levelId, levelName, levelTime);
+
+                    resetCachedLevelContext();
+
+                    return true;
                 }
             }
+
+            return false;
+        }
+
+        bool GAState::checkCachedLevelContext(json& stateDict)
+        {
+            int32_t levelId = utilities::getNumberFromCache(stateDict, "level_id", LevelContext::INVALID_LVL);
+            return levelId > LevelContext::INVALID_LVL;
         }
     }
 }

source/gameanalytics/GAState.h

@@ -148,6 +148,7 @@ namespace gameanalytics
                 static json getValidatedCustomFields(const json& withEventFields);
 
                 int64_t calculateSessionLength() const;
+                bool isLevelTracked() const;
 
         private:
 
@@ -157,12 +158,23 @@ namespace gameanalytics
 
                 int32_t              levelId{INVALID_LVL};
                 std::string          levelName;
-                utilities::Stopwatch timer;
 
-                inline bool IsInLevel() const { return levelId != INVALID_LVL; }
+                inline bool isInLevel() const { return levelId != INVALID_LVL; }
+
+                bool startLevel(int32_t id, std::string const& name);
+                bool endLevel();
+
+                bool resumeLevel(int32_t id, std::string const& name, int64_t timeElapsed = 0);
+                bool resumeLevel();
+                bool pauseLevel();
+
+                int64_t getLevelTime() const;
 
-                bool StartLevel(int32_t id, std::string const& name);
-                bool EndLevel();
+                private:
+
+                utilities::Stopwatch timer;
+                int64_t cachedTime = 0;
+                bool wasContextResumed = false;
             };
 
             GAState();
@@ -201,6 +213,11 @@ namespace gameanalytics
 
             bool updateLevelContext(EGALevelStatus status, int levelId, std::string const& levelName);
 
+            bool cacheLevelContext();
+            bool restoreLevelContext(json& stateDict);
+            bool checkCachedLevelContext(json& stateDict);
+            void resetCachedLevelContext();
+
             threading::GAThreading  _gaThread;
             events::GAEvents        _gaEvents;
             device::GADevice        _gaDevice;