diff --git a/.gitignore b/.gitignore
index bc975bd19f..d1dc476002 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,7 @@ data/*.mwm.routing
 data/*.mwmmeta
 data/[!W]*.mwm
 data/local_ads*.dat
+data/local_ads_*/*.*
 
 # Compiled Python
 *.pyc
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 671fc90fed..b64618011e 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -1080,7 +1080,10 @@ void FrontendRenderer::EndUpdateOverlayTree()
     m_overlayTree->EndOverlayPlacing();
 
     // Track overlays.
-    if (m_overlaysTracker->StartTracking(m_currentZoomLevel))
+    if (m_overlaysTracker->StartTracking(m_currentZoomLevel,
+                                         m_myPositionController->IsModeHasPosition(),
+                                         m_myPositionController->GetDrawablePosition(),
+                                         m_myPositionController->GetHorizontalAccuracy()))
     {
       for (auto const & handle : m_overlayTree->GetHandlesCache())
       {
diff --git a/drape_frontend/my_position_controller.cpp b/drape_frontend/my_position_controller.cpp
index 235ca12792..7467723967 100644
--- a/drape_frontend/my_position_controller.cpp
+++ b/drape_frontend/my_position_controller.cpp
@@ -132,6 +132,7 @@ MyPositionController::MyPositionController(Params && params)
   , m_needBlockAnimation(false)
   , m_wasRotationInScaling(false)
   , m_errorRadius(0.0)
+  , m_horizontalAccuracy(0.0)
   , m_position(m2::PointD::Zero())
   , m_drawDirection(0.0)
   , m_oldPosition(m2::PointD::Zero())
@@ -209,6 +210,11 @@ double MyPositionController::GetErrorRadius() const
   return m_errorRadius;
 }
 
+double MyPositionController::GetHorizontalAccuracy() const
+{
+  return m_horizontalAccuracy;
+}
+
 bool MyPositionController::IsModeChangeViewport() const
 {
   return m_mode == location::Follow || m_mode == location::FollowAndRotate;
@@ -376,6 +382,7 @@ void MyPositionController::OnLocationUpdate(location::GpsInfo const & info, bool
   // there is significant difference between the real location and the estimated one.
   m_position = MercatorBounds::FromLatLon(info.m_latitude, info.m_longitude);
   m_errorRadius = rect.SizeX() * 0.5;
+  m_horizontalAccuracy = info.m_horizontalAccuracy;
 
   if (info.m_speed > 0.0)
   {
diff --git a/drape_frontend/my_position_controller.hpp b/drape_frontend/my_position_controller.hpp
index 68a79ea889..b21e21b480 100644
--- a/drape_frontend/my_position_controller.hpp
+++ b/drape_frontend/my_position_controller.hpp
@@ -76,6 +76,7 @@ public:
 
   m2::PointD const & Position() const;
   double GetErrorRadius() const;
+  double GetHorizontalAccuracy() const;
 
   bool IsModeHasPosition() const;
 
@@ -167,6 +168,7 @@ private:
   ref_ptr<Listener> m_listener;
 
   double m_errorRadius;  // error radius in mercator
+  double m_horizontalAccuracy;
   m2::PointD m_position; // position in mercator
   double m_drawDirection;
   m2::PointD m_oldPosition; // position in mercator
diff --git a/drape_frontend/overlays_tracker.cpp b/drape_frontend/overlays_tracker.cpp
index 33621044d9..e5ae098335 100644
--- a/drape_frontend/overlays_tracker.cpp
+++ b/drape_frontend/overlays_tracker.cpp
@@ -9,7 +9,8 @@ void OverlaysTracker::SetTrackedOverlaysFeatures(std::vector<FeatureID> && ids)
     m_data.insert(std::make_pair(fid, OverlayInfo()));
 }
 
-bool OverlaysTracker::StartTracking(int zoomLevel)
+bool OverlaysTracker::StartTracking(int zoomLevel, bool hasMyPosition,
+                                    m2::PointD const & myPosition, double gpsAccuracy)
 {
   if (zoomLevel < kMinZoomLevel)
   {
@@ -19,6 +20,9 @@ bool OverlaysTracker::StartTracking(int zoomLevel)
   }
 
   m_zoomLevel = zoomLevel;
+  m_hasMyPosition = hasMyPosition;
+  m_myPosition = m_hasMyPosition ? myPosition : m2::PointD();
+  m_gpsAccuracy = m_hasMyPosition ? gpsAccuracy : 0.0;
   for (auto & p : m_data)
     p.second.m_tracked = false;
 
@@ -37,7 +41,9 @@ void OverlaysTracker::Track(FeatureID const & fid)
   if (it->second.m_status == OverlayStatus::Invisible)
   {
     it->second.m_status = OverlayStatus::Visible;
-    m_events.emplace_back(it->first, m_zoomLevel, std::chrono::system_clock::now());
+    m_events.emplace_back(it->first, static_cast<uint8_t>(m_zoomLevel),
+                          std::chrono::steady_clock::now(), m_hasMyPosition,
+                          m_myPosition, m_gpsAccuracy);
   }
 }
 
diff --git a/drape_frontend/overlays_tracker.hpp b/drape_frontend/overlays_tracker.hpp
index 8bf2508b9d..f8adad72e8 100644
--- a/drape_frontend/overlays_tracker.hpp
+++ b/drape_frontend/overlays_tracker.hpp
@@ -13,13 +13,20 @@ namespace df
 struct OverlayShowEvent
 {
   FeatureID m_feature;
-  int m_zoomLevel;
-  std::chrono::system_clock::time_point m_timestamp;
-  OverlayShowEvent(FeatureID const & feature, int zoomLevel,
-                   std::chrono::system_clock::time_point const & timestamp)
+  uint8_t m_zoomLevel;
+  std::chrono::steady_clock::time_point m_timestamp;
+  bool m_hasMyPosition;
+  m2::PointD m_myPosition;
+  double m_gpsAccuracy;
+  OverlayShowEvent(FeatureID const & feature, uint8_t zoomLevel,
+                   std::chrono::steady_clock::time_point const & timestamp,
+                   bool hasMyPosition, m2::PointD const & myPosition, double gpsAccuracy)
     : m_feature(feature)
     , m_zoomLevel(zoomLevel)
     , m_timestamp(timestamp)
+    , m_hasMyPosition(hasMyPosition)
+    , m_myPosition(myPosition)
+    , m_gpsAccuracy(gpsAccuracy)
   {}
 };
 
@@ -34,7 +41,8 @@ public:
 
   void SetTrackedOverlaysFeatures(std::vector<FeatureID> && ids);
 
-  bool StartTracking(int zoomLevel);
+  bool StartTracking(int zoomLevel, bool hasMyPosition,
+                     m2::PointD const & myPosition, double gpsAccuracy);
   void Track(FeatureID const & fid);
   void FinishTracking();
 
@@ -60,6 +68,9 @@ private:
   std::map<FeatureID, OverlayInfo> m_data;
   std::list<OverlayShowEvent> m_events;
   int m_zoomLevel = -1;
+  bool m_hasMyPosition = false;
+  m2::PointD m_myPosition = m2::PointD::Zero();
+  double m_gpsAccuracy = 0.0;
 };
 
 }  // namespace df
diff --git a/local_ads/CMakeLists.txt b/local_ads/CMakeLists.txt
index 1d2e65354e..21abef6020 100644
--- a/local_ads/CMakeLists.txt
+++ b/local_ads/CMakeLists.txt
@@ -5,8 +5,12 @@ set(
   campaign.hpp
   campaign_serialization.cpp
   campaign_serialization.hpp
-  local_ads_helpers.cpp
-  local_ads_helpers.hpp
+  event.cpp
+  event.hpp
+  file_helpers.cpp
+  file_helpers.hpp
+  statistics.cpp
+  statistics.hpp
 )
 
 add_library(${PROJECT_NAME} ${SRC})
diff --git a/local_ads/event.cpp b/local_ads/event.cpp
new file mode 100644
index 0000000000..42683672d7
--- /dev/null
+++ b/local_ads/event.cpp
@@ -0,0 +1,60 @@
+#include "local_ads/event.hpp"
+
+#include "base/math.hpp"
+
+#include <sstream>
+
+namespace local_ads
+{
+Event::Event(EventType type, int64_t mwmVersion, std::string const & countryId, uint32_t featureId,
+             uint8_t zoomLevel, Timestamp const & timestamp, double latitude, double longitude,
+             uint16_t accuracyInMeters)
+  : m_type(type)
+  , m_mwmVersion(mwmVersion)
+  , m_countryId(countryId)
+  , m_featureId(featureId)
+  , m_zoomLevel(zoomLevel)
+  , m_timestamp(timestamp)
+  , m_latitude(latitude)
+  , m_longitude(longitude)
+  , m_accuracyInMeters(accuracyInMeters)
+{
+}
+
+bool Event::operator<(Event const & event) const
+{
+  if (m_mwmVersion != event.m_mwmVersion)
+    return m_mwmVersion < event.m_mwmVersion;
+
+  if (m_countryId != event.m_countryId)
+    return m_countryId < event.m_countryId;
+
+  return m_timestamp < event.m_timestamp;
+}
+
+bool Event::operator==(Event const & event) const
+{
+  double const kEps = 1e-5;
+  using namespace std::chrono;
+  return m_type == event.m_type && m_mwmVersion == event.m_mwmVersion &&
+         m_countryId == event.m_countryId && m_featureId == event.m_featureId &&
+         m_zoomLevel == event.m_zoomLevel &&
+         my::AlmostEqualAbs(m_latitude, event.m_latitude, kEps) &&
+         my::AlmostEqualAbs(m_longitude, event.m_longitude, kEps) &&
+         m_accuracyInMeters == event.m_accuracyInMeters &&
+         duration_cast<seconds>(m_timestamp - event.m_timestamp).count() == 0;
+}
+
+std::string DebugPrint(Event const & event)
+{
+  using namespace std::chrono;
+  std::ostringstream s;
+  s << "[Type:" << static_cast<uint32_t>(event.m_type) << "; Country: " << event.m_countryId
+    << "; Version: " << event.m_mwmVersion << "; FID: " << event.m_featureId
+    << "; Zoom: " << static_cast<uint32_t>(event.m_zoomLevel)
+    << "; Ts: " << duration_cast<std::chrono::seconds>(event.m_timestamp.time_since_epoch()).count()
+    << "; LatLon: " << event.m_latitude << ", " << event.m_longitude
+    << "; Accuracy: " << event.m_accuracyInMeters << "]";
+  return s.str();
+}
+}  // namespace local_ads
diff --git a/local_ads/event.hpp b/local_ads/event.hpp
new file mode 100644
index 0000000000..982bb41c6b
--- /dev/null
+++ b/local_ads/event.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+
+namespace local_ads
+{
+using Timestamp = std::chrono::steady_clock::time_point;
+
+enum class EventType
+{
+  ShowPoint = 0,
+  OpenInfo,
+  ClickedPhone,
+  ClickedWebsite
+};
+
+struct Event
+{
+  EventType m_type;
+  int64_t m_mwmVersion;
+  std::string m_countryId;
+  uint32_t m_featureId;
+  uint8_t m_zoomLevel;
+  Timestamp m_timestamp;
+  double m_latitude;
+  double m_longitude;
+  uint16_t m_accuracyInMeters;
+
+  Event(EventType type, int64_t mwmVersion, std::string const & countryId, uint32_t featureId,
+        uint8_t zoomLevel, Timestamp const & timestamp, double latitude, double longitude,
+        uint16_t accuracyInMeters);
+
+  bool operator<(Event const & event) const;
+  bool operator==(Event const & event) const;
+};
+
+std::string DebugPrint(Event const & event);
+}  // namespace local_ads
diff --git a/local_ads/local_ads_helpers.cpp b/local_ads/file_helpers.cpp
similarity index 74%
rename from local_ads/local_ads_helpers.cpp
rename to local_ads/file_helpers.cpp
index 0ff6060985..1bfdb92069 100644
--- a/local_ads/local_ads_helpers.cpp
+++ b/local_ads/file_helpers.cpp
@@ -1,4 +1,4 @@
-#include "local_ads/local_ads_helpers.hpp"
+#include "local_ads/file_helpers.hpp"
 
 #include "coding/multilang_utf8_string.hpp"
 #include "coding/reader.hpp"
@@ -14,10 +14,10 @@ void WriteCountryName(FileWriter & writer, std::string const & countryName)
   utils::WriteString(writer, countryName);
 }
 
-void WriteDuration(FileWriter & writer, int64_t duration)
+void WriteZigZag(FileWriter & writer, int64_t duration)
 {
-  uint64_t const encodedDuration = bits::ZigZagEncode(duration);
-  WriteToSink(writer, encodedDuration);
+  uint64_t const encoded = bits::ZigZagEncode(duration);
+  WriteToSink(writer, encoded);
 }
 
 void WriteRawData(FileWriter & writer, std::vector<uint8_t> const & rawData)
@@ -34,10 +34,10 @@ std::string ReadCountryName(ReaderSource<FileReader> & src)
   return countryName;
 }
 
-int64_t ReadDuration(ReaderSource<FileReader> & src)
+int64_t ReadZigZag(ReaderSource<FileReader> & src)
 {
-  uint64_t const duration = ReadPrimitiveFromSource<uint64_t>(src);
-  return bits::ZigZagDecode(duration);
+  uint64_t const value = ReadPrimitiveFromSource<uint64_t>(src);
+  return bits::ZigZagDecode(value);
 }
 
 std::vector<uint8_t> ReadRawData(ReaderSource<FileReader> & src)
diff --git a/local_ads/local_ads_helpers.hpp b/local_ads/file_helpers.hpp
similarity index 60%
rename from local_ads/local_ads_helpers.hpp
rename to local_ads/file_helpers.hpp
index df385b96a3..9078e9e36d 100644
--- a/local_ads/local_ads_helpers.hpp
+++ b/local_ads/file_helpers.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "local_ads/event.hpp"
+
 #include "coding/file_reader.hpp"
 #include "coding/file_writer.hpp"
 
@@ -11,26 +13,26 @@ namespace local_ads
 {
 void WriteCountryName(FileWriter & writer, std::string const & countryName);
 
-void WriteDuration(FileWriter & writer, int64_t duration);
+void WriteZigZag(FileWriter & writer, int64_t duration);
 
 template <typename Duration>
-void WriteTimestamp(FileWriter & writer, std::chrono::steady_clock::time_point ts)
+void WriteTimestamp(FileWriter & writer, Timestamp ts)
 {
   int64_t const d = std::chrono::duration_cast<Duration>(ts.time_since_epoch()).count();
-  WriteDuration(writer, d);
+  WriteZigZag(writer, d);
 }
 
 void WriteRawData(FileWriter & writer, std::vector<uint8_t> const & rawData);
 
 std::string ReadCountryName(ReaderSource<FileReader> & src);
 
-int64_t ReadDuration(ReaderSource<FileReader> & src);
+int64_t ReadZigZag(ReaderSource<FileReader> & src);
 
 template <typename Duration>
-std::chrono::steady_clock::time_point ReadTimestamp(ReaderSource<FileReader> & src)
+Timestamp ReadTimestamp(ReaderSource<FileReader> & src)
 {
-  int64_t const d = ReadDuration(src);
-  return std::chrono::steady_clock::time_point(Duration(d));
+  int64_t const d = ReadZigZag(src);
+  return Timestamp(Duration(d));
 }
 
 std::vector<uint8_t> ReadRawData(ReaderSource<FileReader> & src);
diff --git a/local_ads/local_ads.pro b/local_ads/local_ads.pro
index dc7f22d840..2f3a9e6c00 100644
--- a/local_ads/local_ads.pro
+++ b/local_ads/local_ads.pro
@@ -8,10 +8,14 @@ include($$ROOT_DIR/common.pri)
 
 SOURCES += \
     campaign_serialization.cpp \
-    local_ads_helpers.cpp \
+    event.cpp \
+    file_helpers.cpp \
+    statistics.cpp \
 
 
 HEADERS += \
     campaign.hpp \
     campaign_serialization.hpp \
-    local_ads_helpers.hpp \
+    event.hpp \
+    file_helpers.hpp \
+    statistics.hpp \
diff --git a/local_ads/local_ads_tests/CMakeLists.txt b/local_ads/local_ads_tests/CMakeLists.txt
index 62d0e29b95..2e540837e7 100644
--- a/local_ads/local_ads_tests/CMakeLists.txt
+++ b/local_ads/local_ads_tests/CMakeLists.txt
@@ -3,7 +3,8 @@ project(local_ads_tests)
 set(
   SRC
   campaign_serialization_test.cpp
-  local_ads_helpers_tests.cpp
+  file_helpers_tests.cpp
+  statistics_tests.cpp
 )
 
 omim_add_test(${PROJECT_NAME} ${SRC})
@@ -12,6 +13,7 @@ omim_link_libraries(
   ${PROJECT_NAME}
   local_ads
   coding
+  geometry
   platform
   platform_tests_support
   base
diff --git a/local_ads/local_ads_tests/local_ads_helpers_tests.cpp b/local_ads/local_ads_tests/file_helpers_tests.cpp
similarity index 97%
rename from local_ads/local_ads_tests/local_ads_helpers_tests.cpp
rename to local_ads/local_ads_tests/file_helpers_tests.cpp
index 300e55b939..0b48ad4239 100644
--- a/local_ads/local_ads_tests/local_ads_helpers_tests.cpp
+++ b/local_ads/local_ads_tests/file_helpers_tests.cpp
@@ -1,6 +1,6 @@
 #include "testing/testing.hpp"
 
-#include "local_ads/local_ads_helpers.hpp"
+#include "local_ads/file_helpers.hpp"
 
 #include "coding/file_name_utils.hpp"
 
diff --git a/local_ads/local_ads_tests/local_ads_tests.pro b/local_ads/local_ads_tests/local_ads_tests.pro
index d3b8831ea7..20a8e5f018 100644
--- a/local_ads/local_ads_tests/local_ads_tests.pro
+++ b/local_ads/local_ads_tests/local_ads_tests.pro
@@ -4,7 +4,7 @@ CONFIG -= app_bundle
 TEMPLATE = app
 
 ROOT_DIR = ../..
-DEPENDENCIES = local_ads platform_tests_support platform coding base stats_client
+DEPENDENCIES = local_ads platform_tests_support platform coding geometry base stats_client
 
 include($$ROOT_DIR/common.pri)
 
@@ -19,4 +19,5 @@ HEADERS += \
 SOURCES += \
     $$ROOT_DIR/testing/testingmain.cpp \
     campaign_serialization_test.cpp \
-    local_ads_helpers_tests.cpp \
+    file_helpers_tests.cpp \
+    statistics_tests.cpp \
diff --git a/local_ads/local_ads_tests/statistics_tests.cpp b/local_ads/local_ads_tests/statistics_tests.cpp
new file mode 100644
index 0000000000..f79fa0b0dc
--- /dev/null
+++ b/local_ads/local_ads_tests/statistics_tests.cpp
@@ -0,0 +1,164 @@
+#include "testing/testing.hpp"
+
+#include "local_ads/statistics.hpp"
+
+#include "coding/file_name_utils.hpp"
+
+namespace
+{
+class StatisticsGuard
+{
+public:
+  StatisticsGuard(local_ads::Statistics & statistics) : m_statistics(statistics) {}
+  ~StatisticsGuard()
+  {
+    m_statistics.Teardown();
+    m_statistics.CleanupAfterTesting();
+  }
+
+private:
+  local_ads::Statistics & m_statistics;
+};
+}  // namespace
+
+using namespace std::chrono;
+using ET = local_ads::EventType;
+using TS = local_ads::Timestamp;
+
+UNIT_TEST(LocalAdsStatistics_Read_Write_Simple)
+{
+  local_ads::Statistics statistics;
+  StatisticsGuard guard(statistics);
+
+  std::list<local_ads::Event> events;
+  // type, mwmVersion, countryId, featureId, zoomLevel, timestamp, latitude, longitude, accuracyInMeters
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 111, 15, TS(minutes(5)), 30.0, 64.0, 10);
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 222, 13, TS(minutes(10)), 20.0, 14.0, 20);
+  events.emplace_back(ET::OpenInfo, 123456, "Moscow", 111, 17, TS(minutes(15)), 53.0, 54.0, 10000);
+  std::string unusedFileName;
+  auto unprocessedEvents = statistics.WriteEventsForTesting(events, unusedFileName);
+  TEST_EQUAL(unprocessedEvents.size(), 0, ());
+
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), events, ());
+}
+
+UNIT_TEST(LocalAdsStatistics_Write_With_Unprocessed)
+{
+  local_ads::Statistics statistics;
+  StatisticsGuard guard(statistics);
+
+  std::list<local_ads::Event> events;
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 111, 15, TS(minutes(5)), 0.0, 0.0, 10);
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 222, 13, TS(minutes(10)), 20.0, 14.0, 20);
+  events.emplace_back(ET::OpenInfo, 123456, "Moscow", 111, 17, TS(minutes(15)), 15.0, 14.0, 20);
+  std::string fileNameToRebuild;
+  auto unprocessedEvents = statistics.WriteEventsForTesting(events, fileNameToRebuild);
+  TEST_EQUAL(unprocessedEvents.size(), 0, ());
+  TEST(fileNameToRebuild.empty(), ());
+
+  std::list<local_ads::Event> events2;
+  events2.emplace_back(ET::ShowPoint, 123456, "Moscow", 333, 15, TS(minutes(1)), 1.0, 89.0, 20);
+  events2.emplace_back(ET::ShowPoint, 123456, "Moscow", 444, 15, TS(minutes(20)), 30.0, 13.0, 15);
+  auto unprocessedEvents2 = statistics.WriteEventsForTesting(events2, fileNameToRebuild);
+
+  std::list<local_ads::Event> expectedUnprocessedEvents = events2;
+  expectedUnprocessedEvents.sort();
+
+  my::GetNameFromFullPath(fileNameToRebuild);
+  TEST_EQUAL(fileNameToRebuild, "Moscow_123456.dat", ());
+  TEST_EQUAL(expectedUnprocessedEvents, unprocessedEvents2, ());
+}
+
+UNIT_TEST(LocalAdsStatistics_Process_With_Rebuild)
+{
+  local_ads::Statistics statistics;
+  StatisticsGuard guard(statistics);
+
+  std::list<local_ads::Event> events;
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 111, 15, TS(minutes(5)), 50.0, 14.0, 20);
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 222, 13, TS(minutes(10)), 69.0, 67.0, 100);
+  events.emplace_back(ET::OpenInfo, 123456, "Moscow", 111, 17, TS(minutes(15)), 45.0, 80.0, 34);
+  std::string unused;
+  statistics.WriteEventsForTesting(events, unused);
+
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), events, ());
+
+  std::list<local_ads::Event> events2;
+  events2.emplace_back(ET::ShowPoint, 123456, "Moscow", 333, 15, TS(minutes(1)), 20.0, 14.0, 12);
+  events2.emplace_back(ET::ShowPoint, 123456, "Moscow", 444, 15, TS(minutes(20)), 30.0, 56.0, 3535);
+
+  statistics.ProcessEventsForTesting(events2);
+
+  std::list<local_ads::Event> expectedResult = events;
+  expectedResult.insert(expectedResult.end(), events2.begin(), events2.end());
+  expectedResult.sort();
+
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), expectedResult, ());
+}
+
+UNIT_TEST(LocalAdsStatistics_Process_With_Clipping)
+{
+  local_ads::Statistics statistics;
+  StatisticsGuard guard(statistics);
+
+  std::list<local_ads::Event> events;
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 111, 15, TS(minutes(5)), 20.0, 14.0, 12);
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 222, 13, TS(minutes(10)), 69.0, 67.0, 100);
+  events.emplace_back(ET::OpenInfo, 123456, "Moscow", 111, 17, TS(minutes(25 * 60 + 15)), 20.0,
+                      14.0, 20);
+  std::string unused;
+  statistics.WriteEventsForTesting(events, unused);
+
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), events, ());
+
+  std::list<local_ads::Event> events2;
+  events2.emplace_back(ET::ShowPoint, 123456, "Moscow", 333, 15, TS(minutes(24 * 183 * 60 + 50)),
+                       20.0, 14.0, 20);
+
+  statistics.ProcessEventsForTesting(events2);
+
+  std::list<local_ads::Event> expectedResult;
+  expectedResult.push_back(local_ads::Event(events.back()));
+  expectedResult.insert(expectedResult.end(), events2.begin(), events2.end());
+  expectedResult.sort();
+
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), expectedResult, ());
+}
+
+UNIT_TEST(LocalAdsStatistics_Process_Complex)
+{
+  local_ads::Statistics statistics;
+  StatisticsGuard guard(statistics);
+
+  std::list<local_ads::Event> events;
+  events.emplace_back(ET::ShowPoint, 123456, "Moscow", 111, 15, TS(minutes(5)), 20.0, 14.0, 20);
+  events.emplace_back(ET::ShowPoint, 123456, "Minsk", 222, 13, TS(minutes(10)), 30.0, 14.0, 20);
+  events.emplace_back(ET::OpenInfo, 123456, "Minsk", 111, 17, TS(minutes(25)), 40.0, 14.0, 20);
+  events.emplace_back(ET::OpenInfo, 123456, "Minsk", 111, 17, TS(minutes(25 * 60 + 15)), 20.0, 14.0,
+                      20);
+  std::string unused;
+  statistics.WriteEventsForTesting(events, unused);
+
+  std::list<local_ads::Event> expectedResult1;
+  expectedResult1.push_back(local_ads::Event(events.front()));
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), expectedResult1, ());
+
+  std::list<local_ads::Event> expectedResult2 = events;
+  expectedResult2.erase(expectedResult2.begin());
+  TEST_EQUAL(statistics.ReadEventsForTesting("Minsk_123456.dat"), expectedResult2, ());
+
+  std::list<local_ads::Event> events2;
+  events2.emplace_back(ET::ShowPoint, 123456, "Moscow", 333, 15, TS(minutes(100)), 20.0, 14.0, 20);
+  events2.emplace_back(ET::ShowPoint, 123456, "Minsk", 333, 15, TS(minutes(24 * 183 * 60 + 50)),
+                       20.0, 14.0, 20);
+
+  statistics.ProcessEventsForTesting(events2);
+
+  expectedResult1.push_back(local_ads::Event(events2.front()));
+  TEST_EQUAL(statistics.ReadEventsForTesting("Moscow_123456.dat"), expectedResult1, ());
+
+  expectedResult2.clear();
+  expectedResult2.push_back(local_ads::Event(events.back()));
+  expectedResult2.push_back(local_ads::Event(events2.back()));
+  TEST_EQUAL(statistics.ReadEventsForTesting("Minsk_123456.dat"), expectedResult2, ());
+}
diff --git a/local_ads/statistics.cpp b/local_ads/statistics.cpp
new file mode 100644
index 0000000000..d1514eacf1
--- /dev/null
+++ b/local_ads/statistics.cpp
@@ -0,0 +1,532 @@
+#include "local_ads/statistics.hpp"
+#include "local_ads/file_helpers.hpp"
+
+#include "platform/http_client.hpp"
+#include "platform/platform.hpp"
+
+#include "coding/file_name_utils.hpp"
+#include "coding/file_writer.hpp"
+#include "coding/point_to_integer.hpp"
+#include "coding/url_encode.hpp"
+#include "coding/write_to_sink.hpp"
+
+#include "geometry/mercator.hpp"
+
+#include "base/assert.hpp"
+#include "base/logging.hpp"
+#include "base/string_utils.hpp"
+
+#include <functional>
+#include <sstream>
+
+namespace
+{
+std::string const kStatisticsFolderName = "local_ads_stats";
+std::string const kStatisticsExt = ".dat";
+
+uint64_t constexpr kMaxFilesSizeInBytes = 10 * 1024 * 1024;
+float const kEventsDisposingRate = 0.2f;
+
+auto constexpr kSendingTimeout = std::chrono::hours(1);
+int64_t constexpr kEventMaxLifetimeInSeconds = 24 * 183 * 3600;  // About half of year.
+auto constexpr kDeletionPeriod = std::chrono::hours(24);
+
+// TODO: set correct address
+std::string const kStatisticsServer = "";
+
+void WriteMetadata(FileWriter & writer, std::string const & countryId, int64_t mwmVersion,
+                   local_ads::Timestamp const & ts)
+{
+  local_ads::WriteCountryName(writer, countryId);
+  local_ads::WriteZigZag(writer, mwmVersion);
+  local_ads::WriteTimestamp<std::chrono::seconds>(writer, ts);
+}
+
+void ReadMetadata(ReaderSource<FileReader> & src, std::string & countryId, int64_t & mwmVersion,
+                  local_ads::Timestamp & ts)
+{
+  countryId = local_ads::ReadCountryName(src);
+  mwmVersion = local_ads::ReadZigZag(src);
+  ts = local_ads::ReadTimestamp<std::chrono::seconds>(src);
+}
+
+void WritePackedData(FileWriter & writer, local_ads::Statistics::PackedData && packedData)
+{
+  WriteToSink(writer, packedData.m_eventType);
+  WriteToSink(writer, packedData.m_zoomLevel);
+  WriteToSink(writer, packedData.m_featureIndex);
+  WriteToSink(writer, packedData.m_seconds);
+  local_ads::WriteZigZag(writer, packedData.m_mercator);
+  WriteToSink(writer, packedData.m_accuracy);
+}
+
+template <typename ToDo>
+void ReadPackedData(ReaderSource<FileReader> & src, ToDo && toDo)
+{
+  using PackedData = local_ads::Statistics::PackedData;
+
+  std::string countryId;
+  int64_t mwmVersion;
+  local_ads::Timestamp baseTimestamp;
+  ReadMetadata(src, countryId, mwmVersion, baseTimestamp);
+  while (src.Size() > 0)
+  {
+    PackedData data;
+    data.m_eventType = ReadPrimitiveFromSource<uint8_t>(src);
+    data.m_zoomLevel = ReadPrimitiveFromSource<uint8_t>(src);
+    data.m_featureIndex = ReadPrimitiveFromSource<uint32_t>(src);
+    data.m_seconds = ReadPrimitiveFromSource<uint32_t>(src);
+    data.m_mercator = local_ads::ReadZigZag(src);
+    data.m_accuracy = ReadPrimitiveFromSource<uint16_t>(src);
+    toDo(std::move(data), countryId, mwmVersion, baseTimestamp);
+  }
+}
+
+template <typename ToDo>
+void FilterEvents(std::list<local_ads::Event> const & events, std::string const & countryId,
+                  int64_t mwmVersion, ToDo && toDo)
+{
+  for (auto const & event : events)
+  {
+    if (event.m_countryId != countryId || event.m_mwmVersion != mwmVersion)
+      continue;
+    toDo(event);
+  }
+}
+
+local_ads::Timestamp GetMinTimestamp(std::list<local_ads::Event> const & events,
+                                     std::string const & countryId, int64_t mwmVersion)
+{
+  local_ads::Timestamp minTimestamp = local_ads::Timestamp::max();
+  FilterEvents(events, countryId, mwmVersion, [&minTimestamp](local_ads::Event const & event)
+  {
+    if (event.m_timestamp < minTimestamp)
+      minTimestamp = event.m_timestamp;
+  });
+  return minTimestamp;
+}
+
+local_ads::Timestamp GetMaxTimestamp(std::list<local_ads::Event> const & events,
+                                     std::string const & countryId, int64_t mwmVersion)
+{
+  local_ads::Timestamp maxTimestamp = local_ads::Timestamp::min();
+  FilterEvents(events, countryId, mwmVersion, [&maxTimestamp](local_ads::Event const & event)
+  {
+    if (event.m_timestamp > maxTimestamp)
+      maxTimestamp = event.m_timestamp;
+  });
+  return maxTimestamp;
+}
+
+std::string GetPath(std::string const & fileName)
+{
+  return my::JoinFoldersToPath({GetPlatform().WritableDir(), kStatisticsFolderName}, fileName);
+}
+
+std::string GetPath(local_ads::Event const & event)
+{
+  return GetPath(event.m_countryId + "_" + strings::to_string(event.m_mwmVersion) + kStatisticsExt);
+}
+
+std::string StatisticsFolder()
+{
+  return GetPath("");
+}
+
+void CreateDirIfNotExist()
+{
+  std::string const statsFolder = StatisticsFolder();
+  if (!GetPlatform().IsFileExistsByFullPath(statsFolder))
+    GetPlatform().MkDir(statsFolder);
+}
+
+std::string MakeRemoteURL(std::string const & userId, std::string const & name, int64_t version)
+{
+  if (kStatisticsServer.empty())
+    return {};
+
+  std::ostringstream ss;
+  ss << kStatisticsServer << "/";
+  ss << UrlEncode(userId) << "/";
+  ss << version << "/";
+  ss << UrlEncode(name);
+  return ss.str();
+}
+}  // namespace
+
+namespace local_ads
+{
+Statistics::~Statistics()
+{
+  std::lock_guard<std::mutex> lock(m_mutex);
+  ASSERT(!m_isRunning, ());
+}
+
+void Statistics::Startup()
+{
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_isRunning)
+      return;
+    m_isRunning = true;
+  }
+  m_thread = threads::SimpleThread(&Statistics::ThreadRoutine, this);
+}
+
+void Statistics::Teardown()
+{
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (!m_isRunning)
+      return;
+    m_isRunning = false;
+  }
+  m_condition.notify_one();
+  m_thread.join();
+}
+
+bool Statistics::RequestEvents(std::list<Event> & events, bool & needToSend)
+{
+  std::unique_lock<std::mutex> lock(m_mutex);
+
+  bool const isTimeout = !m_condition.wait_for(lock, kSendingTimeout, [this]
+  {
+    return !m_isRunning || !m_events.empty();
+  });
+
+  if (!m_isRunning)
+    return false;
+
+  using namespace std::chrono;
+  needToSend = isTimeout || (steady_clock::now() > (m_lastSending + kSendingTimeout));
+
+  events = std::move(m_events);
+  m_events.clear();
+  return true;
+}
+
+void Statistics::RegisterEvent(Event && event)
+{
+  std::lock_guard<std::mutex> lock(m_mutex);
+  if (!m_isRunning)
+    return;
+  m_events.push_back(std::move(event));
+  m_condition.notify_one();
+}
+
+void Statistics::RegisterEvents(std::list<Event> && events)
+{
+  std::lock_guard<std::mutex> lock(m_mutex);
+  if (!m_isRunning)
+    return;
+  m_events.splice(m_events.end(), std::move(events));
+  m_condition.notify_one();
+}
+
+void Statistics::ThreadRoutine()
+{
+  std::list<Event> events;
+  bool needToSend = false;
+  while (RequestEvents(events, needToSend))
+  {
+    ProcessEvents(events);
+    events.clear();
+
+    // Send statistics to server.
+    if (needToSend)
+      SendToServer();
+  }
+}
+
+std::list<Event> Statistics::WriteEvents(std::list<Event> & events, std::string & fileNameToRebuild)
+{
+  try
+  {
+    CreateDirIfNotExist();
+    if (m_metadataCache.empty())
+      IndexMetadata();
+
+    std::unique_ptr<FileWriter> writer;
+
+    events.sort();
+
+    auto eventIt = events.begin();
+    for (; eventIt != events.end(); ++eventIt)
+    {
+      Event const & event = *eventIt;
+      MetadataKey const key = std::make_pair(event.m_countryId, event.m_mwmVersion);
+      auto it = m_metadataCache.find(key);
+
+      // Get metadata.
+      Metadata metadata;
+      bool needWriteMetadata = false;
+      if (it == m_metadataCache.end())
+      {
+        metadata.m_timestamp = GetMinTimestamp(events, event.m_countryId, event.m_mwmVersion);
+        metadata.m_fileName = GetPath(event);
+        m_metadataCache[key] = metadata;
+        needWriteMetadata = true;
+      }
+      else
+      {
+        metadata = it->second;
+      }
+
+      if (writer == nullptr || writer->GetName() != metadata.m_fileName)
+        writer = my::make_unique<FileWriter>(metadata.m_fileName, FileWriter::OP_APPEND);
+
+      if (needWriteMetadata)
+        WriteMetadata(*writer, event.m_countryId, event.m_mwmVersion, metadata.m_timestamp);
+
+      // Check if timestamp is out of date. In this case we have to rebuild events package.
+      using namespace std::chrono;
+      int64_t const s = duration_cast<seconds>(event.m_timestamp - metadata.m_timestamp).count();
+      if (s < 0 || s > kEventMaxLifetimeInSeconds)
+      {
+        fileNameToRebuild = writer->GetName();
+
+        // Return unprocessed events.
+        std::list<Event> unprocessedEvents;
+        unprocessedEvents.splice(unprocessedEvents.end(), events, eventIt, events.end());
+        return unprocessedEvents;
+      }
+
+      PackedData data;
+      data.m_featureIndex = event.m_featureId;
+      data.m_seconds = static_cast<uint32_t>(s);
+      data.m_zoomLevel = event.m_zoomLevel;
+      data.m_eventType = static_cast<uint8_t>(event.m_type);
+      auto const mercatorPt = MercatorBounds::FromLatLon(event.m_latitude, event.m_longitude);
+      data.m_mercator = PointToInt64(mercatorPt, POINT_COORD_BITS);
+      data.m_accuracy = event.m_accuracyInMeters;
+      WritePackedData(*writer, std::move(data));
+    }
+  }
+  catch (RootException const & ex)
+  {
+    LOG(LWARNING, (ex.Msg()));
+  }
+  return std::list<Event>();
+}
+
+std::list<Event> Statistics::ReadEvents(std::string const & fileName) const
+{
+  std::list<Event> result;
+  if (!GetPlatform().IsFileExistsByFullPath(fileName))
+    return result;
+
+  try
+  {
+    FileReader reader(fileName);
+    ReaderSource<FileReader> src(reader);
+    ReadPackedData(src, [&result](PackedData && data, std::string const & countryId,
+                                  int64_t mwmVersion, Timestamp const & baseTimestamp) {
+      auto const mercatorPt = Int64ToPoint(data.m_mercator, POINT_COORD_BITS);
+      result.emplace_back(static_cast<EventType>(data.m_eventType), mwmVersion, countryId,
+                          data.m_featureIndex, data.m_zoomLevel,
+                          baseTimestamp + std::chrono::seconds(data.m_seconds),
+                          MercatorBounds::YToLat(mercatorPt.y),
+                          MercatorBounds::XToLon(mercatorPt.x), data.m_accuracy);
+    });
+  }
+  catch (Reader::Exception const & ex)
+  {
+    LOG(LWARNING, ("Error reading file:", fileName, ex.Msg()));
+  }
+  return result;
+}
+
+void Statistics::ProcessEvents(std::list<Event> & events)
+{
+  bool needRebuild;
+  do
+  {
+    std::string fileNameToRebuild;
+    auto unprocessedEvents = WriteEvents(events, fileNameToRebuild);
+    needRebuild = !unprocessedEvents.empty();
+    if (!needRebuild)
+      break;
+
+    // The first event in the list is cause of writing interruption.
+    Event event = unprocessedEvents.front();
+
+    // Read events and merge with unprocessed ones.
+    std::list<Event> newEvents = ReadEvents(fileNameToRebuild);
+    newEvents.splice(newEvents.end(), std::move(unprocessedEvents));
+    newEvents.sort();
+
+    // Clip obsolete events.
+    auto constexpr kLifetime = std::chrono::seconds(kEventMaxLifetimeInSeconds);
+    auto const maxTimestamp = GetMaxTimestamp(newEvents, event.m_countryId, event.m_mwmVersion);
+    auto newMinTimestamp = maxTimestamp - kLifetime + kDeletionPeriod;
+    for (auto eventIt = newEvents.begin(); eventIt != newEvents.end();)
+    {
+      if (eventIt->m_countryId == event.m_countryId &&
+          eventIt->m_mwmVersion == event.m_mwmVersion && eventIt->m_timestamp < newMinTimestamp)
+      {
+        eventIt = newEvents.erase(eventIt);
+      }
+      else
+      {
+        ++eventIt;
+      }
+    }
+
+    // Update run-time cache and delete rebuilding file.
+    m_metadataCache.erase(MetadataKey(event.m_countryId, event.m_mwmVersion));
+    FileWriter::DeleteFileX(fileNameToRebuild);
+    std::swap(events, newEvents);
+  } while (needRebuild);
+}
+
+void Statistics::SendToServer()
+{
+  for (auto it = m_metadataCache.begin(); it != m_metadataCache.end();)
+  {
+    std::string const url = MakeRemoteURL(m_userId, it->first.first, it->first.second);
+    if (url.empty())
+      return;
+
+    std::vector<uint8_t> bytes = SerializeForServer(ReadEvents(it->second.m_fileName));
+    if (bytes.empty())
+    {
+      ++it;
+      continue;
+    }
+
+    platform::HttpClient request(url);
+    request.SetBodyData(std::string(bytes.begin(), bytes.end()), "application/octet-stream");
+    if (request.RunHttpRequest() && request.ErrorCode() == 200)
+    {
+      FileWriter::DeleteFileX(it->second.m_fileName);
+      it = m_metadataCache.erase(it);
+    }
+    else
+    {
+      ++it;
+    }
+  }
+  m_lastSending = std::chrono::steady_clock::now();
+}
+
+std::vector<uint8_t> Statistics::SerializeForServer(std::list<Event> const & events) const
+{
+  if (events.empty())
+    return {};
+
+  // TODO: implement serialization
+  return std::vector<uint8_t>{1, 2, 3, 4, 5};
+}
+
+std::list<Event> Statistics::WriteEventsForTesting(std::list<Event> const & events,
+                                                   std::string & fileNameToRebuild)
+{
+  std::list<Event> mutableEvents = events;
+  return WriteEvents(mutableEvents, fileNameToRebuild);
+}
+
+void Statistics::IndexMetadata()
+{
+  std::vector<std::string> files;
+  GetPlatform().GetFilesByExt(StatisticsFolder(), kStatisticsExt, files);
+  for (auto const & filename : files)
+    ExtractMetadata(GetPath(filename));
+  BalanceMemory();
+}
+
+void Statistics::ExtractMetadata(std::string const & fileName)
+{
+  ASSERT(GetPlatform().IsFileExistsByFullPath(fileName), ());
+  try
+  {
+    std::string countryId;
+    int64_t mwmVersion;
+    Timestamp baseTimestamp;
+    {
+      FileReader reader(fileName);
+      ReaderSource<FileReader> src(reader);
+      ReadMetadata(src, countryId, mwmVersion, baseTimestamp);
+    }
+    MetadataKey const key = std::make_pair(countryId, mwmVersion);
+    auto it = m_metadataCache.find(key);
+    if (it != m_metadataCache.end())
+    {
+      // The only statistics file for countryId + mwmVersion must exist.
+      if (it->second.m_timestamp < baseTimestamp)
+        FileWriter::DeleteFileX(it->second.m_fileName);
+      else
+        FileWriter::DeleteFileX(fileName);
+    }
+    m_metadataCache[key] = Metadata(fileName, baseTimestamp);
+  }
+  catch (Reader::Exception const & ex)
+  {
+    LOG(LWARNING, ("Error reading file:", fileName, ex.Msg()));
+  }
+}
+
+void Statistics::BalanceMemory()
+{
+  std::map<MetadataKey, uint64_t> sizeInBytes;
+  uint64_t totalSize = 0;
+  for (auto const & metadata : m_metadataCache)
+  {
+    FileReader reader(metadata.second.m_fileName);
+    sizeInBytes[metadata.first] = reader.Size();
+    totalSize += reader.Size();
+  }
+
+  if (totalSize < kMaxFilesSizeInBytes)
+    return;
+
+  auto constexpr kPackedDataSize =
+      sizeof(PackedData::m_featureIndex) + sizeof(PackedData::m_seconds) +
+      sizeof(PackedData::m_accuracy) + sizeof(PackedData::m_mercator) +
+      sizeof(PackedData::m_zoomLevel) + sizeof(PackedData::m_eventType);
+  for (auto const & metadata : sizeInBytes)
+  {
+    auto const disposingSize = static_cast<uint64_t>(metadata.second * kEventsDisposingRate);
+    auto const disposingCount = disposingSize / kPackedDataSize;
+
+    std::string fileName = m_metadataCache[metadata.first].m_fileName;
+    std::list<Event> events = ReadEvents(fileName);
+    m_metadataCache.erase(metadata.first);
+    FileWriter::DeleteFileX(fileName);
+    if (events.size() <= disposingCount)
+      continue;
+
+    events.sort();
+    auto it = events.begin();
+    std::advance(it, static_cast<size_t>(disposingCount));
+    events.erase(events.begin(), it);
+
+    std::string fileNameToRebuild;
+    WriteEvents(events, fileNameToRebuild);
+    ASSERT(fileNameToRebuild.empty(), ());
+  }
+}
+
+void Statistics::SetUserId(std::string const & userId)
+{
+  std::lock_guard<std::mutex> lock(m_mutex);
+  m_userId = userId;
+}
+
+std::list<Event> Statistics::ReadEventsForTesting(std::string const & fileName)
+{
+  return ReadEvents(GetPath(fileName));
+}
+
+void Statistics::ProcessEventsForTesting(std::list<Event> const & events)
+{
+  std::list<Event> mutableEvents = events;
+  ProcessEvents(mutableEvents);
+}
+
+void Statistics::CleanupAfterTesting()
+{
+  std::string const statsFolder = StatisticsFolder();
+  if (GetPlatform().IsFileExistsByFullPath(statsFolder))
+    GetPlatform().RmDirRecursively(statsFolder);
+}
+}  // namespace local_ads
diff --git a/local_ads/statistics.hpp b/local_ads/statistics.hpp
new file mode 100644
index 0000000000..27f1a5eb52
--- /dev/null
+++ b/local_ads/statistics.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "local_ads/event.hpp"
+
+#include "base/thread.hpp"
+
+#include <chrono>
+#include <list>
+#include <map>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace local_ads
+{
+class Statistics final
+{
+public:
+  struct PackedData
+  {
+    int64_t m_mercator = 0;
+    uint32_t m_featureIndex = 0;
+    uint32_t m_seconds = 0;
+    uint16_t m_accuracy = 0;
+    uint8_t m_eventType = 0;
+    uint8_t m_zoomLevel = 0;
+  };
+
+  Statistics() = default;
+  ~Statistics();
+
+  void Startup();
+  void Teardown();
+
+  void SetUserId(std::string const & userId);
+
+  void RegisterEvent(Event && event);
+  void RegisterEvents(std::list<Event> && events);
+
+  std::list<Event> WriteEventsForTesting(std::list<Event> const & events,
+                                         std::string & fileNameToRebuild);
+  std::list<Event> ReadEventsForTesting(std::string const & fileName);
+  void ProcessEventsForTesting(std::list<Event> const & events);
+  void CleanupAfterTesting();
+
+private:
+  void ThreadRoutine();
+  bool RequestEvents(std::list<Event> & events, bool & needToSend);
+
+  void IndexMetadata();
+  void ExtractMetadata(std::string const & fileName);
+  void BalanceMemory();
+
+  std::list<Event> WriteEvents(std::list<Event> & events, std::string & fileNameToRebuild);
+  std::list<Event> ReadEvents(std::string const & fileName) const;
+  void ProcessEvents(std::list<Event> & events);
+
+  void SendToServer();
+  std::vector<uint8_t> SerializeForServer(std::list<Event> const & events) const;
+
+  using MetadataKey = std::pair<std::string, int64_t>;
+  struct Metadata
+  {
+    std::string m_fileName;
+    Timestamp m_timestamp;
+
+    Metadata() = default;
+    Metadata(std::string const & fileName, Timestamp const & timestamp)
+      : m_fileName(fileName), m_timestamp(timestamp)
+    {
+    }
+  };
+  std::map<MetadataKey, Metadata> m_metadataCache;
+  Timestamp m_lastSending;
+
+  std::string m_userId;
+
+  bool m_isRunning = false;
+  std::list<Event> m_events;
+
+  std::condition_variable m_condition;
+  std::mutex m_mutex;
+  threads::SimpleThread m_thread;
+};
+}  // namespace local_ads
diff --git a/map/framework.cpp b/map/framework.cpp
index 1218330628..0af8cbc9ff 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -437,7 +437,10 @@ Framework::Framework(FrameworkParams const & params)
   , m_lastReportedCountry(kInvalidCountryId)
 {
   if (!params.m_disableLocalAds)
+  {
     m_localAdsManager.Startup();
+    m_localAdsManager.GetStatistics().SetUserId(GetPlatform().UniqueClientId());
+  }
 
   m_startBackgroundTime = my::Timer::LocalTime();
 
@@ -1783,11 +1786,26 @@ void Framework::CreateDrapeEngine(ref_ptr<dp::OGLContextFactory> contextFactory,
     });
   };
 
-  auto overlaysShowStatsFn = [](std::list<df::OverlayShowEvent> && events)
+  auto overlaysShowStatsFn = [this](std::list<df::OverlayShowEvent> && events)
   {
-    // TODO: implement sending events. This callback is called on a render thread,
-    // so placing here not lightweight code is strictly prohibited! The best option is
-    // redirection events to another thread.
+    if (events.empty())
+      return;
+
+    std::list<local_ads::Event> statEvents;
+    for (auto const & event : events)
+    {
+      auto const & mwmInfo = event.m_feature.m_mwmId.GetInfo();
+      if (!mwmInfo)
+        continue;
+
+      statEvents.emplace_back(local_ads::EventType::ShowPoint,
+                              mwmInfo->GetVersion(), mwmInfo->GetCountryName(),
+                              event.m_feature.m_index, event.m_zoomLevel, event.m_timestamp,
+                              MercatorBounds::YToLat(event.m_myPosition.y),
+                              MercatorBounds::XToLon(event.m_myPosition.x),
+                              static_cast<uint16_t>(event.m_gpsAccuracy));
+    }
+    m_localAdsManager.GetStatistics().RegisterEvents(std::move(statEvents));
   };
 
   auto isCountryLoadedByNameFn = bind(&Framework::IsCountryLoadedByName, this, _1);
diff --git a/map/local_ads_manager.cpp b/map/local_ads_manager.cpp
index 150bddfdde..8b0bae5c0c 100644
--- a/map/local_ads_manager.cpp
+++ b/map/local_ads_manager.cpp
@@ -1,7 +1,7 @@
 #include "map/local_ads_manager.hpp"
 
 #include "local_ads/campaign_serialization.hpp"
-#include "local_ads/local_ads_helpers.hpp"
+#include "local_ads/file_helpers.hpp"
 
 #include "drape_frontend/drape_engine.hpp"
 #include "drape_frontend/visual_params.hpp"
@@ -70,6 +70,8 @@ void LocalAdsManager::Startup()
     m_isRunning = true;
   }
   m_thread = threads::SimpleThread(&LocalAdsManager::ThreadRoutine, this);
+
+  m_statistics.Startup();
 }
 
 void LocalAdsManager::Teardown()
@@ -82,6 +84,8 @@ void LocalAdsManager::Teardown()
   }
   m_condition.notify_one();
   m_thread.join();
+
+  m_statistics.Teardown();
 }
 
 void LocalAdsManager::SetDrapeEngine(ref_ptr<df::DrapeEngine> engine)
diff --git a/map/local_ads_manager.hpp b/map/local_ads_manager.hpp
index 5978646481..75fbfbbfda 100644
--- a/map/local_ads_manager.hpp
+++ b/map/local_ads_manager.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "local_ads/statistics.hpp"
+
 #include "drape_frontend/custom_symbol.hpp"
 
 #include "drape/pointers.hpp"
@@ -28,7 +30,7 @@ class LocalAdsManager final
 public:
   using GetMwmsByRectFn = function<std::vector<MwmSet::MwmId>(m2::RectD const &)>;
   using GetMwmIdByName = function<MwmSet::MwmId(std::string const &)>;
-  using Timestamp = std::chrono::steady_clock::time_point;
+  using Timestamp = local_ads::Timestamp;
 
   LocalAdsManager(GetMwmsByRectFn const & getMwmsByRectFn, GetMwmIdByName const & getMwmIdByName);
   LocalAdsManager(LocalAdsManager && /* localAdsManager */) = default;
@@ -44,6 +46,8 @@ public:
 
   void Invalidate();
 
+  local_ads::Statistics & GetStatistics() { return m_statistics; }
+  local_ads::Statistics const & GetStatistics() const { return m_statistics; }
 private:
   enum class RequestType
   {
@@ -86,4 +90,6 @@ private:
   std::vector<Request> m_requestedCampaigns;
   std::mutex m_mutex;
   threads::SimpleThread m_thread;
+
+  local_ads::Statistics m_statistics;
 };
diff --git a/qt/qt_common/map_widget.cpp b/qt/qt_common/map_widget.cpp
index 13f45cecf2..a92c38b80a 100644
--- a/qt/qt_common/map_widget.cpp
+++ b/qt/qt_common/map_widget.cpp
@@ -56,7 +56,10 @@ MapWidget::MapWidget(Framework & framework, QWidget * parent)
 MapWidget::~MapWidget()
 {
   m_framework.EnterBackground();
+  m_framework.SetRenderingDisabled(true);
+  m_contextFactory->PrepareToShutdown();
   m_framework.DestroyDrapeEngine();
+  m_contextFactory.reset();
 }
 
 void MapWidget::BindHotkeys(QWidget & parent)
diff --git a/qt/qt_common/qtoglcontextfactory.cpp b/qt/qt_common/qtoglcontextfactory.cpp
index e3e1fd6c51..cf16bb3850 100644
--- a/qt/qt_common/qtoglcontextfactory.cpp
+++ b/qt/qt_common/qtoglcontextfactory.cpp
@@ -22,9 +22,14 @@ QtOGLContextFactory::~QtOGLContextFactory()
   m_uploadSurface->destroy();
 }
 
+void QtOGLContextFactory::PrepareToShutdown()
+{
+  m_preparedToShutdown = true;
+}
+
 bool QtOGLContextFactory::LockFrame()
 {
-  if (!m_drawContext)
+  if (m_preparedToShutdown || !m_drawContext)
     return false;
 
   m_drawContext->lockFrame();
diff --git a/qt/qt_common/qtoglcontextfactory.hpp b/qt/qt_common/qtoglcontextfactory.hpp
index 918be36b81..21c133d229 100644
--- a/qt/qt_common/qtoglcontextfactory.hpp
+++ b/qt/qt_common/qtoglcontextfactory.hpp
@@ -18,6 +18,8 @@ public:
   QtOGLContextFactory(QOpenGLContext * rootContext);
   ~QtOGLContextFactory() override;
 
+  void PrepareToShutdown();
+
   bool LockFrame();
   GLuint GetTextureHandle() const;
   QRectF const & GetTexRect() const;
@@ -37,6 +39,7 @@ private:
   std::unique_ptr<QOffscreenSurface> m_drawSurface;
   std::unique_ptr<QtUploadOGLContext> m_uploadContext;
   std::unique_ptr<QOffscreenSurface> m_uploadSurface;
+  bool m_preparedToShutdown = false;
 };
 }  // namespace common
 }  // namespace qt
diff --git a/xcode/local_ads/local_ads.xcodeproj/project.pbxproj b/xcode/local_ads/local_ads.xcodeproj/project.pbxproj
index 965c61216e..00c49cb0f7 100644
--- a/xcode/local_ads/local_ads.xcodeproj/project.pbxproj
+++ b/xcode/local_ads/local_ads.xcodeproj/project.pbxproj
@@ -7,9 +7,15 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		45812AAF1E977D2200D7D3B3 /* local_ads_helpers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45812AAD1E977D2200D7D3B3 /* local_ads_helpers.cpp */; };
-		45812AB01E977D2200D7D3B3 /* local_ads_helpers.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45812AAE1E977D2200D7D3B3 /* local_ads_helpers.hpp */; };
-		45812AB31E977D4500D7D3B3 /* local_ads_helpers_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45812AB11E977D4000D7D3B3 /* local_ads_helpers_tests.cpp */; };
+		455C5DA51E97EBAC00DBFE48 /* file_helpers_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 455C5DA11E97EBA200DBFE48 /* file_helpers_tests.cpp */; };
+		455C5DA61E97EBAF00DBFE48 /* statistics_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 455C5DA21E97EBA200DBFE48 /* statistics_tests.cpp */; };
+		455C5DAD1E97EBC300DBFE48 /* event.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 455C5DA71E97EBC300DBFE48 /* event.cpp */; };
+		455C5DAE1E97EBC300DBFE48 /* event.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 455C5DA81E97EBC300DBFE48 /* event.hpp */; };
+		455C5DAF1E97EBC300DBFE48 /* file_helpers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 455C5DA91E97EBC300DBFE48 /* file_helpers.cpp */; };
+		455C5DB01E97EBC300DBFE48 /* file_helpers.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 455C5DAA1E97EBC300DBFE48 /* file_helpers.hpp */; };
+		455C5DB11E97EBC300DBFE48 /* statistics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 455C5DAB1E97EBC300DBFE48 /* statistics.cpp */; };
+		455C5DB21E97EBC300DBFE48 /* statistics.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 455C5DAC1E97EBC300DBFE48 /* statistics.hpp */; };
+		4580DAC61E9D2C3D00E8BCDE /* libgeometry.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4580DAC51E9D2C3D00E8BCDE /* libgeometry.a */; };
 		45812AB51E9781D500D7D3B3 /* libplatform_tests_support.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 45812AB41E9781D500D7D3B3 /* libplatform_tests_support.a */; };
 		45FFD6571E965E0600DB854E /* campaign_serialization.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45FFD6541E965E0600DB854E /* campaign_serialization.cpp */; };
 		45FFD6581E965E0600DB854E /* campaign_serialization.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45FFD6551E965E0600DB854E /* campaign_serialization.hpp */; };
@@ -25,9 +31,15 @@
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
-		45812AAD1E977D2200D7D3B3 /* local_ads_helpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = local_ads_helpers.cpp; sourceTree = "<group>"; };
-		45812AAE1E977D2200D7D3B3 /* local_ads_helpers.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = local_ads_helpers.hpp; sourceTree = "<group>"; };
-		45812AB11E977D4000D7D3B3 /* local_ads_helpers_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = local_ads_helpers_tests.cpp; sourceTree = "<group>"; };
+		455C5DA11E97EBA200DBFE48 /* file_helpers_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = file_helpers_tests.cpp; sourceTree = "<group>"; };
+		455C5DA21E97EBA200DBFE48 /* statistics_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = statistics_tests.cpp; sourceTree = "<group>"; };
+		455C5DA71E97EBC300DBFE48 /* event.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = event.cpp; sourceTree = "<group>"; };
+		455C5DA81E97EBC300DBFE48 /* event.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = event.hpp; sourceTree = "<group>"; };
+		455C5DA91E97EBC300DBFE48 /* file_helpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = file_helpers.cpp; sourceTree = "<group>"; };
+		455C5DAA1E97EBC300DBFE48 /* file_helpers.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = file_helpers.hpp; sourceTree = "<group>"; };
+		455C5DAB1E97EBC300DBFE48 /* statistics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = statistics.cpp; sourceTree = "<group>"; };
+		455C5DAC1E97EBC300DBFE48 /* statistics.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = statistics.hpp; sourceTree = "<group>"; };
+		4580DAC51E9D2C3D00E8BCDE /* libgeometry.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgeometry.a; path = "../../../omim-build/xcode/Debug-iphonesimulator/libgeometry.a"; sourceTree = "<group>"; };
 		45812AB41E9781D500D7D3B3 /* libplatform_tests_support.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libplatform_tests_support.a; path = "../../../omim-build/xcode/Debug-iphonesimulator/libplatform_tests_support.a"; sourceTree = "<group>"; };
 		45FFD6461E965DBB00DB854E /* liblocal_ads.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = liblocal_ads.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		45FFD6541E965E0600DB854E /* campaign_serialization.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = campaign_serialization.cpp; sourceTree = "<group>"; };
@@ -57,6 +69,7 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				4580DAC61E9D2C3D00E8BCDE /* libgeometry.a in Frameworks */,
 				45FFD68A1E96639400DB854E /* libz.tbd in Frameworks */,
 				45FFD6881E96637C00DB854E /* libalohalitics.a in Frameworks */,
 				45FFD6861E96636A00DB854E /* libcoding.a in Frameworks */,
@@ -96,9 +109,13 @@
 			children = (
 				45FFD6541E965E0600DB854E /* campaign_serialization.cpp */,
 				45FFD6551E965E0600DB854E /* campaign_serialization.hpp */,
-				45812AAD1E977D2200D7D3B3 /* local_ads_helpers.cpp */,
-				45812AAE1E977D2200D7D3B3 /* local_ads_helpers.hpp */,
 				45FFD6561E965E0600DB854E /* campaign.hpp */,
+				455C5DA71E97EBC300DBFE48 /* event.cpp */,
+				455C5DA81E97EBC300DBFE48 /* event.hpp */,
+				455C5DA91E97EBC300DBFE48 /* file_helpers.cpp */,
+				455C5DAA1E97EBC300DBFE48 /* file_helpers.hpp */,
+				455C5DAB1E97EBC300DBFE48 /* statistics.cpp */,
+				455C5DAC1E97EBC300DBFE48 /* statistics.hpp */,
 			);
 			name = local_ads;
 			path = ../../local_ads;
@@ -109,7 +126,8 @@
 			children = (
 				45FFD67D1E96633300DB854E /* testingmain.cpp */,
 				45FFD6791E965F3C00DB854E /* campaign_serialization_test.cpp */,
-				45812AB11E977D4000D7D3B3 /* local_ads_helpers_tests.cpp */,
+				455C5DA11E97EBA200DBFE48 /* file_helpers_tests.cpp */,
+				455C5DA21E97EBA200DBFE48 /* statistics_tests.cpp */,
 			);
 			name = local_ads_tests;
 			path = ../../local_ads/local_ads_tests;
@@ -118,6 +136,7 @@
 		45FFD6801E96634B00DB854E /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
+				4580DAC51E9D2C3D00E8BCDE /* libgeometry.a */,
 				45812AB41E9781D500D7D3B3 /* libplatform_tests_support.a */,
 				45FFD6891E96639400DB854E /* libz.tbd */,
 				45FFD6871E96637C00DB854E /* libalohalitics.a */,
@@ -135,9 +154,11 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				455C5DB01E97EBC300DBFE48 /* file_helpers.hpp in Headers */,
 				45FFD6591E965E0600DB854E /* campaign.hpp in Headers */,
+				455C5DAE1E97EBC300DBFE48 /* event.hpp in Headers */,
 				45FFD6581E965E0600DB854E /* campaign_serialization.hpp in Headers */,
-				45812AB01E977D2200D7D3B3 /* local_ads_helpers.hpp in Headers */,
+				455C5DB21E97EBC300DBFE48 /* statistics.hpp in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -231,8 +252,10 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				45812AAF1E977D2200D7D3B3 /* local_ads_helpers.cpp in Sources */,
+				455C5DAD1E97EBC300DBFE48 /* event.cpp in Sources */,
 				45FFD6571E965E0600DB854E /* campaign_serialization.cpp in Sources */,
+				455C5DB11E97EBC300DBFE48 /* statistics.cpp in Sources */,
+				455C5DAF1E97EBC300DBFE48 /* file_helpers.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -240,9 +263,10 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				45812AB31E977D4500D7D3B3 /* local_ads_helpers_tests.cpp in Sources */,
 				45FFD67C1E96630B00DB854E /* campaign_serialization_test.cpp in Sources */,
 				45FFD67F1E96634100DB854E /* testingmain.cpp in Sources */,
+				455C5DA61E97EBAF00DBFE48 /* statistics_tests.cpp in Sources */,
+				455C5DA51E97EBAC00DBFE48 /* file_helpers_tests.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};