[eye][tips] Additional requirements are supported

6 files changed, 415 insertions, 6 deletions

diff --git a/metrics/eye.cpp b/metrics/eye.cpp
index 939a95c311..b32aecb82a 100644
--- a/metrics/eye.cpp
+++ b/metrics/eye.cpp
@@ -100,6 +100,76 @@ void Eye::AppendTip(Tip::Type type, Tip::Event event)
   Save(editableInfo);
 }
 
+void Eye::UpdateBookingFilterUsedTime()
+{
+  auto const info = m_info.Get();
+  auto editableInfo = std::make_shared<Info>(*info);
+
+  editableInfo->m_booking.m_lastFilterUsedTime = Clock::now();
+
+  Save(editableInfo);
+}
+
+void Eye::UpdateBoomarksCatalogShownTime()
+{
+  auto const info = m_info.Get();
+  auto editableInfo = std::make_shared<Info>(*info);
+
+  editableInfo->m_bookmarks.m_lastOpenedTime = Clock::now();
+
+  Save(editableInfo);
+}
+
+void Eye::UpdateDiscoveryShownTime()
+{
+  auto const info = m_info.Get();
+  auto editableInfo = std::make_shared<Info>(*info);
+
+  editableInfo->m_discovery.m_lastOpenedTime = Clock::now();
+
+  Save(editableInfo);
+}
+
+void Eye::IncrementDiscoveryItem(Discovery::Event event)
+{
+  auto const info = m_info.Get();
+  auto editableInfo = std::make_shared<Info>(*info);
+
+  editableInfo->m_discovery.m_lastClickedTime = Clock::now();
+  editableInfo->m_discovery.m_eventCounters.Increment(event);
+
+  Save(editableInfo);
+}
+
+void Eye::AppendLayer(Layer::Type type)
+{
+  auto const info = m_info.Get();
+  auto editableInfo = std::make_shared<Info>(*info);
+  auto & editableLayers = editableInfo->m_layers;
+
+  auto it = std::find_if(editableLayers.begin(), editableLayers.end(), [type](Layer const & layer)
+  {
+    return layer.m_type == type;
+  });
+
+  if (it != editableLayers.end())
+  {
+    ++it->m_useCount;
+    it->m_lastTimeUsed = Clock::now();
+  }
+  else
+  {
+    Layer layer;
+    layer.m_type = type;
+
+    ++layer.m_useCount;
+    layer.m_lastTimeUsed = Clock::now();
+    editableLayers.emplace_back(std::move(layer));
+  }
+
+  Save(editableInfo);
+}
+
 // Eye::Event methods ------------------------------------------------------------------------------
 // static
 void Eye::Event::TipShown(Tip::Type type, Tip::Event event)
@@ -109,4 +179,49 @@ void Eye::Event::TipShown(Tip::Type type, Tip::Event event)
     Instance().AppendTip(type, event);
   });
 }
+
+// static
+void Eye::Event::BookingFilterUsed()
+{
+  GetPlatform().RunTask(Platform::Thread::File, []
+  {
+    Instance().UpdateBookingFilterUsedTime();
+  });
+}
+
+// static
+void Eye::Event::BoomarksCatalogShown()
+{
+  GetPlatform().RunTask(Platform::Thread::File, []
+  {
+    Instance().UpdateBoomarksCatalogShownTime();
+  });
+}
+
+// static
+void Eye::Event::DiscoveryShown()
+{
+  GetPlatform().RunTask(Platform::Thread::File, []
+  {
+    Instance().UpdateDiscoveryShownTime();
+  });
+}
+
+// static
+void Eye::Event::DiscoveryItemClicked(Discovery::Event event)
+{
+  GetPlatform().RunTask(Platform::Thread::File, [event]
+  {
+    Instance().IncrementDiscoveryItem(event);
+  });
+}
+
+// static
+void Eye::Event::LayerUsed(Layer::Type type)
+{
+  GetPlatform().RunTask(Platform::Thread::File, [type]
+  {
+    Instance().AppendLayer(type);
+  });
+}
 }  // namespace eye
diff --git a/metrics/eye.hpp b/metrics/eye.hpp
index 06d0b2b5a8..2268cf616d 100644
--- a/metrics/eye.hpp
+++ b/metrics/eye.hpp
@@ -21,6 +21,11 @@ public:
   {
   public:
     static void TipShown(Tip::Type type, Tip::Event event);
+    static void BookingFilterUsed();
+    static void BoomarksCatalogShown();
+    static void DiscoveryShown();
+    static void DiscoveryItemClicked(Discovery::Event event);
+    static void LayerUsed(Layer::Type type);
   };
 
   static Eye & Instance();
@@ -34,6 +39,11 @@ private:
 
   // Event processing:
   void AppendTip(Tip::Type type, Tip::Event event);
+  void UpdateBookingFilterUsedTime();
+  void UpdateBoomarksCatalogShownTime();
+  void UpdateDiscoveryShownTime();
+  void IncrementDiscoveryItem(Discovery::Event event);
+  void AppendLayer(Layer::Type type);
 
   base::AtomicSharedPtr<Info> m_info;
 
diff --git a/metrics/eye_info.hpp b/metrics/eye_info.hpp
index eb51753778..66e67592e4 100644
--- a/metrics/eye_info.hpp
+++ b/metrics/eye_info.hpp
@@ -7,9 +7,10 @@
 #include "base/visitor.hpp"
 
 #include <array>
+#include <cstdint>
 #include <chrono>
 #include <string>
-#include <tuple>
+#include <type_traits>
 #include <vector>
 
 namespace eye
@@ -67,6 +68,64 @@ enum class Version : int8_t
 using Clock = std::chrono::system_clock;
 using Time = Clock::time_point;
 
+struct Booking
+{
+  DECLARE_VISITOR(visitor(m_lastFilterUsedTime, "last_filter_used_time"))
+
+  Time m_lastFilterUsedTime;
+};
+
+struct Bookmarks
+{
+  DECLARE_VISITOR(visitor(m_lastOpenedTime, "last_use_time"))
+
+  Time m_lastOpenedTime;
+};
+
+struct Discovery
+{
+  enum class Event
+  {
+    HotelsClicked,
+    AttractionsClicked,
+    CafesClicked,
+    LocalsClicked,
+
+    MoreHotelsClicked,
+    MoreAttractionsClicked,
+    MoreCafesClicked,
+    MoreLocalsClicked,
+
+    Count
+  };
+
+  DECLARE_VISITOR(visitor(m_eventCounters, "event_counters"),
+                  visitor(m_lastOpenedTime, "last_opened_time"),
+                  visitor(m_lastClickedTime, "last_clicked_time"))
+
+  Counters<Event, uint32_t> m_eventCounters;
+  Time m_lastOpenedTime;
+  Time m_lastClickedTime;
+};
+
+struct Layer
+{
+  enum Type
+  {
+    TrafficJams,
+    PublicTransport
+  };
+
+  DECLARE_VISITOR(visitor(m_type, "type"), visitor(m_useCount, "use_count"),
+                  visitor(m_lastTimeUsed, "last_time_used"))
+
+  Type m_type;
+  uint64_t m_useCount = 0;
+  Time m_lastTimeUsed;
+};
+
+using Layers = std::vector<Layer>;
+
 struct Tip
 {
   // The order is important.
@@ -102,8 +161,14 @@ using Tips = std::vector<Tip>;
 struct InfoV0
 {
   static Version GetVersion() { return Version::V0; }
-  DECLARE_VISITOR(visitor(m_tips, "tips"))
-
+  DECLARE_VISITOR(visitor(m_booking, "booking"), visitor(m_bookmarks, "bookmarks"),
+                  visitor(m_discovery, "discovery"), visitor(m_layers, "layers"),
+                  visitor(m_tips, "tips"))
+
+  Booking m_booking;
+  Bookmarks m_bookmarks;
+  Discovery m_discovery;
+  Layers m_layers;
   Tips m_tips;
 };
 
diff --git a/metrics/metrics_tests/eye_tests.cpp b/metrics/metrics_tests/eye_tests.cpp
index 2c51f8473a..6e01004c41 100644
--- a/metrics/metrics_tests/eye_tests.cpp
+++ b/metrics/metrics_tests/eye_tests.cpp
@@ -50,6 +50,18 @@ Time GetLastShownTipTime(Tips const & tips)
 
   return lastShownTime;
 }
+
+Time GetLastShownLayerTime(Layers const & layers)
+{
+  Time lastUsedTime;
+  for (auto const & layer : layers)
+  {
+    if (lastUsedTime < layer.m_lastTimeUsed)
+      lastUsedTime = layer.m_lastTimeUsed;
+  }
+
+  return lastUsedTime;
+}
 }  // namespace
 
 UNIT_TEST(Eye_SerdesTest)
@@ -139,3 +151,175 @@ UNIT_CLASS_TEST(ScopedEyeForTesting, AppendTipTest)
     TEST_NOT_EQUAL(prevShowTime, lastShownTipTime, ());
   }
 }
+
+UNIT_CLASS_TEST(ScopedEyeForTesting, UpdateBookingFilterUsedTimeTest)
+{
+  auto const initialInfo = Eye::Instance().GetInfo();
+  auto const & initialBooking = initialInfo->m_booking;
+
+  TEST_EQUAL(initialBooking.m_lastFilterUsedTime, Time(), ());
+
+  EyeForTesting::UpdateBookingFilterUsedTime();
+
+  auto const info = Eye::Instance().GetInfo();
+  auto const & booking = info->m_booking;
+
+  TEST_NOT_EQUAL(initialBooking.m_lastFilterUsedTime, booking.m_lastFilterUsedTime, ());
+}
+
+UNIT_CLASS_TEST(ScopedEyeForTesting, UpdateBoomarksCatalogShownTimeTest)
+{
+  auto const initialInfo = Eye::Instance().GetInfo();
+  auto const & initialBookmarks = initialInfo->m_bookmarks;
+
+  TEST_EQUAL(initialBookmarks.m_lastOpenedTime, Time(), ());
+
+  EyeForTesting::UpdateBoomarksCatalogShownTime();
+
+  auto const info = Eye::Instance().GetInfo();
+  auto const & bookmarks = info->m_bookmarks;
+
+  TEST_NOT_EQUAL(initialBookmarks.m_lastOpenedTime, bookmarks.m_lastOpenedTime, ());
+}
+
+UNIT_CLASS_TEST(ScopedEyeForTesting, UpdateDiscoveryShownTimeTest)
+{
+  auto const initialInfo = Eye::Instance().GetInfo();
+  auto const & initialDiscovery = initialInfo->m_discovery;
+
+  TEST_EQUAL(initialDiscovery.m_lastOpenedTime, Time(), ());
+
+  EyeForTesting::UpdateDiscoveryShownTime();
+
+  auto const info = Eye::Instance().GetInfo();
+  auto const & discovery = info->m_discovery;
+
+  TEST_NOT_EQUAL(initialDiscovery.m_lastOpenedTime, discovery.m_lastOpenedTime, ());
+}
+
+UNIT_CLASS_TEST(ScopedEyeForTesting, IncrementDiscoveryItemTest)
+{
+  auto const initialInfo = Eye::Instance().GetInfo();
+  auto const & initialDiscovery = initialInfo->m_discovery;
+
+  TEST_EQUAL(initialDiscovery.m_lastClickedTime, Time(), ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::AttractionsClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::CafesClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::HotelsClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::LocalsClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::MoreAttractionsClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::MoreCafesClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::MoreHotelsClicked), 0, ());
+  TEST_EQUAL(initialDiscovery.m_eventCounters.Get(Discovery::Event::MoreLocalsClicked), 0, ());
+
+  {
+    EyeForTesting::IncrementDiscoveryItem(Discovery::Event::CafesClicked);
+
+    auto const info = Eye::Instance().GetInfo();
+    auto const & discovery = info->m_discovery;
+
+    TEST_NOT_EQUAL(initialDiscovery.m_lastClickedTime, discovery.m_lastClickedTime, ());
+
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::AttractionsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::CafesClicked), 1, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::HotelsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::LocalsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreAttractionsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreCafesClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreHotelsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreLocalsClicked), 0, ());
+  }
+
+  {
+    EyeForTesting::IncrementDiscoveryItem(Discovery::Event::CafesClicked);
+
+    auto const info = Eye::Instance().GetInfo();
+    auto const & discovery = info->m_discovery;
+
+    TEST_NOT_EQUAL(initialDiscovery.m_lastClickedTime, discovery.m_lastClickedTime, ());
+
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::AttractionsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::CafesClicked), 2, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::HotelsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::LocalsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreAttractionsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreCafesClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreHotelsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreLocalsClicked), 0, ());
+  }
+
+  {
+    EyeForTesting::IncrementDiscoveryItem(Discovery::Event::CafesClicked);
+    EyeForTesting::IncrementDiscoveryItem(Discovery::Event::HotelsClicked);
+    EyeForTesting::IncrementDiscoveryItem(Discovery::Event::MoreLocalsClicked);
+    EyeForTesting::IncrementDiscoveryItem(Discovery::Event::MoreHotelsClicked);
+
+    auto const info = Eye::Instance().GetInfo();
+    auto const & discovery = info->m_discovery;
+
+    TEST_NOT_EQUAL(initialDiscovery.m_lastClickedTime, discovery.m_lastClickedTime, ());
+
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::AttractionsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::CafesClicked), 3, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::HotelsClicked), 1, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::LocalsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreAttractionsClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreCafesClicked), 0, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreHotelsClicked), 1, ());
+    TEST_EQUAL(discovery.m_eventCounters.Get(Discovery::Event::MoreLocalsClicked), 1, ());
+  }
+}
+
+UNIT_CLASS_TEST(ScopedEyeForTesting, AppendLayerTest)
+{
+  {
+    auto const initialInfo = Eye::Instance().GetInfo();
+    auto const & initialLayers = initialInfo->m_layers;
+
+    TEST(initialLayers.empty(), ());
+    TEST_EQUAL(GetLastShownLayerTime(initialLayers), Time(), ());
+  }
+  Time prevShowTime;
+  {
+    EyeForTesting::AppendLayer(Layer::Type::PublicTransport);
+
+    auto const info = Eye::Instance().GetInfo();
+    auto const & layers = info->m_layers;
+    auto const prevShowTime = GetLastShownLayerTime(layers);
+
+    TEST_EQUAL(layers.size(), 1, ());
+    TEST_NOT_EQUAL(layers[0].m_lastTimeUsed, Time(), ());
+    TEST_EQUAL(layers[0].m_type, Layer::Type::PublicTransport, ());
+    TEST_EQUAL(layers[0].m_useCount, 1, ());
+    TEST_NOT_EQUAL(prevShowTime, Time(), ());
+  }
+  {
+    EyeForTesting::AppendLayer(Layer::Type::TrafficJams);
+
+    auto const info = Eye::Instance().GetInfo();
+    auto const & layers = info->m_layers;
+    auto const lastShownLayerTime = GetLastShownLayerTime(layers);
+
+    TEST_EQUAL(layers.size(), 2, ());
+    TEST_NOT_EQUAL(layers[1].m_lastTimeUsed, Time(), ());
+    TEST_EQUAL(layers[1].m_type, Layer::Type::TrafficJams, ());
+    TEST_EQUAL(layers[1].m_useCount, 1, ());
+    TEST_EQUAL(layers[1].m_lastTimeUsed, lastShownLayerTime, ());
+    TEST_NOT_EQUAL(prevShowTime, lastShownLayerTime, ());
+    prevShowTime = lastShownLayerTime;
+  }
+  {
+    EyeForTesting::AppendLayer(Layer::Type::TrafficJams);
+
+    auto const info = Eye::Instance().GetInfo();
+    auto const & layers = info->m_layers;
+    auto const lastShownLayerTime = GetLastShownLayerTime(layers);
+
+    TEST_EQUAL(layers.size(), 2, ());
+    TEST_NOT_EQUAL(layers[1].m_lastTimeUsed, Time(), ());
+    TEST_EQUAL(layers[1].m_type, Layer::Type::TrafficJams, ());
+    TEST_EQUAL(layers[1].m_useCount, 2, ());
+    TEST_EQUAL(layers[1].m_lastTimeUsed, lastShownLayerTime, ());
+    TEST_NOT_EQUAL(prevShowTime, lastShownLayerTime, ());
+  }
+}
diff --git a/metrics/metrics_tests_support/eye_for_testing.cpp b/metrics/metrics_tests_support/eye_for_testing.cpp
index 8411811391..97c294ead1 100644
--- a/metrics/metrics_tests_support/eye_for_testing.cpp
+++ b/metrics/metrics_tests_support/eye_for_testing.cpp
@@ -21,14 +21,44 @@ void EyeForTesting::ResetEye()
 }
 
 // static
+void EyeForTesting::SetInfo(Info const & info)
+{
+  Eye::Instance().m_info.Set(std::make_shared<Info>(info));
+}
+
+// static
 void EyeForTesting::AppendTip(Tip::Type type, Tip::Event event)
 {
   Eye::Instance().AppendTip(type, event);
 }
 
 // static
-void EyeForTesting::SetInfo(Info const & info)
+void EyeForTesting::UpdateBookingFilterUsedTime()
 {
-  Eye::Instance().m_info.Set(std::make_shared<Info>(info));
+  Eye::Instance().UpdateBookingFilterUsedTime();
+}
+
+// static
+void EyeForTesting::UpdateBoomarksCatalogShownTime()
+{
+  Eye::Instance().UpdateBoomarksCatalogShownTime();
+}
+
+// static
+void EyeForTesting::UpdateDiscoveryShownTime()
+{
+  Eye::Instance().UpdateDiscoveryShownTime();
+}
+
+// static
+void EyeForTesting::IncrementDiscoveryItem(Discovery::Event event)
+{
+  Eye::Instance().IncrementDiscoveryItem(event);
+}
+
+// static
+void EyeForTesting::AppendLayer(Layer::Type type)
+{
+  Eye::Instance().AppendLayer(type);
 }
 }  // namespace eye
diff --git a/metrics/metrics_tests_support/eye_for_testing.hpp b/metrics/metrics_tests_support/eye_for_testing.hpp
index 09c515c463..87795d9692 100644
--- a/metrics/metrics_tests_support/eye_for_testing.hpp
+++ b/metrics/metrics_tests_support/eye_for_testing.hpp
@@ -8,8 +8,13 @@ class EyeForTesting
 {
 public:
   static void ResetEye();
-  static void AppendTip(Tip::Type type, Tip::Event event);
   static void SetInfo(Info const & info);
+  static void AppendTip(Tip::Type type, Tip::Event event);
+  static void UpdateBookingFilterUsedTime();
+  static void UpdateBoomarksCatalogShownTime();
+  static void UpdateDiscoveryShownTime();
+  static void IncrementDiscoveryItem(Discovery::Event event);
+  static void AppendLayer(Layer::Type type);
 };
 
 class ScopedEyeForTesting