pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[notifications][core] UGC notifications v2

Browse source
This commit is contained in:
Arsentiy Milchakov 2019-01-31 18:49:16 +03:00 • committed by Aleksandr Zatsepin
parent e8626a9199
commit 2f8b4f98e6
13 changed files with 330 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
coding/serdes_json.hpp
View file

@ -170,6 +170,12 @@ public:
});
}
template <typename Optional>
void operator()(Optional const & opt, Optional const &, char const * name = nullptr)
{
(*this)(opt, name);
}
protected:
template <typename Fn>
void NewScopeWith(base::JSONPtr json_object, char const * name, Fn && fn)
@ -370,6 +376,19 @@ public:
RestoreContext(outerContext);
}
template <typename Optional>
void operator()(Optional & opt, Optional const & defaultValue, char const * name = nullptr)
{
auto json = base::GetJSONOptionalField(m_json, name);
if (!json)
{
opt = defaultValue;
return;
}
(*this)(opt, name);
}
protected:
json_t * SaveContext(char const * name = nullptr)
{

3
map/CMakeLists.txt
View file

@ -79,6 +79,9 @@ set(
mwm_url.hpp
notifications/notification_manager.cpp
notifications/notification_manager.hpp
notifications/notification_manager_delegate.cpp
notifications/notification_manager_delegate.hpp
notifications/notification_queue.cpp
notifications/notification_queue.hpp
notifications/notification_queue_serdes.cpp
notifications/notification_queue_serdes.hpp

21
map/framework.cpp
View file

@ -6,6 +6,7 @@
#include "map/ge0_parser.hpp"
#include "map/geourl_process.hpp"
#include "map/gps_tracker.hpp"
#include "map/notifications/notification_manager_delegate.hpp"
#include "map/taxi_delegate.hpp"
#include "map/user_mark.hpp"
#include "map/utils.hpp"
@ -380,6 +381,9 @@ void Framework::Migrate(bool keepDownloaded)
InitDiscoveryManager();
InitTaxiEngine();
RegisterAllMaps();
m_notificationManager.SetDelegate(
std::make_unique<notifications::NotificationManagerDelegate>(m_model.GetDataSource(),
*m_cityFinder, *m_ugcApi));
m_trafficManager.SetCurrentDataVersion(GetStorage().GetCurrentDataVersion());
if (m_drapeEngine && m_isRenderingEnabled)
@ -424,7 +428,6 @@ Framework::Framework(FrameworkParams const & params)
, m_descriptionsLoader(std::make_unique<descriptions::Loader>(m_model.GetDataSource()))
, m_purchase(std::make_unique<Purchase>())
, m_tipsApi(static_cast<TipsApi::Delegate &>(*this))
, m_notificationManager(static_cast<notifications::NotificationManager::Delegate &>(*this))
{
CHECK(IsLittleEndian(), ("Only little-endian architectures are supported."));
@ -547,6 +550,9 @@ Framework::Framework(FrameworkParams const & params)
InitTransliteration();
LOG(LDEBUG, ("Transliterators initialized"));
m_notificationManager.SetDelegate(
std::make_unique<notifications::NotificationManagerDelegate>(m_model.GetDataSource(),
*m_cityFinder, *m_ugcApi));
m_notificationManager.Load();
m_notificationManager.TrimExpired();
@ -807,18 +813,7 @@ void Framework::ResetBookmarkInfo(Bookmark const & bmk, place_page::Info & info)
search::ReverseGeocoder::Address Framework::GetAddressAtPoint(m2::PointD const & pt) const
{
double const kDistanceThresholdMeters = 0.5;
search::ReverseGeocoder const coder(m_model.GetDataSource());
search::ReverseGeocoder::Address address;
coder.GetNearbyAddress(pt, address);
// We do not init nearby address info for points that are located
// outside of the nearby building.
if (address.GetDistance() < kDistanceThresholdMeters)
return address;
return {};
return utils::GetAddressAtPoint(m_model.GetDataSource(), pt);
}
void Framework::FillFeatureInfo(FeatureID const & fid, place_page::Info & info) const

4
map/framework.hpp
View file

@ -145,7 +145,6 @@ struct FrameworkParams
class Framework : public SearchAPI::Delegate,
public RoutingManager::Delegate,
public TipsApi::Delegate,
public notifications::NotificationManager::Delegate,
private power_management::PowerManager::Subscriber
{
DISALLOW_COPY(Framework);
@ -263,8 +262,7 @@ public:
booking::Api const * GetBookingApi(platform::NetworkPolicy const & policy) const;
taxi::Engine * GetTaxiEngine(platform::NetworkPolicy const & policy);
locals::Api * GetLocalsApi(platform::NetworkPolicy const & policy);
// NotificationManager::Delegate override.
ugc::Api * GetUGCApi() override { return m_ugcApi.get(); }
ugc::Api * GetUGCApi() { return m_ugcApi.get(); }
ugc::Api const * GetUGCApi() const { return m_ugcApi.get(); }
df::DrapeApi & GetDrapeApi() { return m_drapeApi; }

109
map/map_tests/notification_tests.cpp
View file

@ -13,15 +13,30 @@
#include <utility>
using namespace notifications;
using namespace std::chrono;
namespace notifications
{
class NotificationManagerForTesting : public NotificationManager
{
public:
explicit NotificationManagerForTesting(NotificationManager::Delegate & delegate)
: NotificationManager(delegate)
class NotificationManagerDelegate : public NotificationManager::Delegate
{
public:
ugc::Api & GetUGCApi() override
{
UNREACHABLE();
}
string GetAddress(m2::PointD const & pt) override
{
return {};
}
};
NotificationManagerForTesting()
{
SetDelegate(std::make_unique<NotificationManagerDelegate>());
}
Queue & GetEditableQueue() { return m_queue; }
@ -30,6 +45,11 @@ public:
{
ProcessUgcRateCandidates(poi);
}
static void SetCreatedTime(NotificationCandidate & dst, Time time)
{
dst.m_created = time;
}
};
} // namespace notifications
@ -44,54 +64,35 @@ public:
}
};
class DelegateForTesting : public NotificationManager::Delegate
{
public:
// NotificationManager::Delegate overrides:
ugc::Api * GetUGCApi() override
{
return nullptr;
}
};
Queue MakeDefaultQueueForTesting()
{
Queue queue;
{
NotificationCandidate notification;
notification.m_type = NotificationCandidate::Type::UgcReview;
eye::MapObject mapObject;
mapObject.SetBestType("cafe");
mapObject.SetPos({15.686299, 73.704084});
mapObject.SetReadableName("Baba");
notification.m_mapObject = std::make_unique<eye::MapObject>();
notification.m_mapObject->SetBestType("cafe");
notification.m_mapObject->SetPos({15.686299, 73.704084});
notification.m_mapObject->SetReadableName("Baba");
queue.m_candidates.emplace_back(std::move(notification));
queue.m_candidates.emplace_back(mapObject, "");
}
{
NotificationCandidate notification;
notification.m_type = NotificationCandidate::Type::UgcReview;
eye::MapObject mapObject;
mapObject.SetBestType("shop");
mapObject.SetPos({12.923975, 100.776627});
mapObject.SetReadableName("7eleven");
notification.m_mapObject = std::make_unique<eye::MapObject>();
notification.m_mapObject->SetBestType("shop");
notification.m_mapObject->SetPos({12.923975, 100.776627});
notification.m_mapObject->SetReadableName("7eleven");
queue.m_candidates.emplace_back(std::move(notification));
queue.m_candidates.emplace_back(mapObject, "");
}
{
NotificationCandidate notification;
notification.m_type = NotificationCandidate::Type::UgcReview;
eye::MapObject mapObject;
mapObject.SetBestType("viewpoint");
mapObject.SetPos({-45.943995, 167.619933});
mapObject.SetReadableName("Waiau");
notification.m_mapObject = std::make_unique<eye::MapObject>();
notification.m_mapObject->SetBestType("viewpoint");
notification.m_mapObject->SetPos({-45.943995, 167.619933});
notification.m_mapObject->SetReadableName("Waiau");
queue.m_candidates.emplace_back(std::move(notification));
queue.m_candidates.emplace_back(mapObject, "");
}
return queue;
@ -107,11 +108,10 @@ void CompareWithDefaultQueue(Queue const & lhs)
{
auto const & lhsItem = lhs.m_candidates[i];
auto const & rhsItem = rhs.m_candidates[i];
TEST_EQUAL(lhsItem.m_type, rhsItem.m_type, ());
TEST(lhsItem.m_mapObject, ());
TEST_EQUAL(lhsItem.m_mapObject->GetBestType(), rhsItem.m_mapObject->GetBestType(), ());
TEST_EQUAL(lhsItem.m_mapObject->GetReadableName(), rhsItem.m_mapObject->GetReadableName(), ());
TEST_EQUAL(lhsItem.m_mapObject->GetPos(), lhsItem.m_mapObject->GetPos(), ());
TEST_EQUAL(lhsItem.GetType(), rhsItem.GetType(), ());
TEST_EQUAL(lhsItem.GetBestFeatureType(), rhsItem.GetBestFeatureType(), ());
TEST_EQUAL(lhsItem.GetReadableName(), rhsItem.GetReadableName(), ());
TEST_EQUAL(lhsItem.GetPos(), lhsItem.GetPos(), ());
}
}
@ -144,8 +144,7 @@ UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_QueueSaveLoadTest)
UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckRouteToInSameGeoTrigger)
{
DelegateForTesting delegate;
NotificationManagerForTesting notificationManager(delegate);
NotificationManagerForTesting notificationManager;
eye::MapObject mapObject;
mapObject.SetPos(MercatorBounds::FromLatLon({59.909299, 10.769807}));
@ -160,12 +159,14 @@ UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckRouteToInSam
notificationManager.OnMapObjectEvent(mapObject);
TEST_EQUAL(notificationManager.GetEditableQueue().m_candidates.size(), 1, ());
notificationManager.GetEditableQueue().m_candidates[0].m_created = event.m_eventTime;
auto & candidate = notificationManager.GetEditableQueue().m_candidates[0];
NotificationManagerForTesting::SetCreatedTime(candidate, event.m_eventTime);
auto result = notificationManager.GetNotification();
TEST(result.is_initialized(), ());
TEST_EQUAL(result.get().m_type, NotificationCandidate::Type::UgcReview, ());
TEST_EQUAL(result.get().GetType(), NotificationCandidate::Type::UgcReview, ());
result = notificationManager.GetNotification();
TEST(!result.is_initialized(), ());
@ -173,8 +174,7 @@ UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckRouteToInSam
UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckUgcNotSavedTrigger)
{
DelegateForTesting delegate;
NotificationManagerForTesting notificationManager(delegate);
NotificationManagerForTesting notificationManager;
eye::MapObject mapObject;
mapObject.SetPos(MercatorBounds::FromLatLon({59.909299, 10.769807}));
@ -207,13 +207,13 @@ UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckUgcNotSavedT
TEST(!result.is_initialized(), ());
notificationManager.GetEditableQueue().m_candidates[0].m_created =
notifications::Clock::now() - std::chrono::hours(25);
auto & candidate = notificationManager.GetEditableQueue().m_candidates[0];
NotificationManagerForTesting::SetCreatedTime(candidate, Clock::now() - hours(25));
result = notificationManager.GetNotification();
TEST(result.is_initialized(), ());
TEST_EQUAL(result.get().m_type, NotificationCandidate::Type::UgcReview, ());
TEST_EQUAL(result.get().GetType(), NotificationCandidate::Type::UgcReview, ());
result = notificationManager.GetNotification();
TEST(!result.is_initialized(), ());
@ -242,8 +242,7 @@ UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckUgcNotSavedT
UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckPlannedTripTrigger)
{
DelegateForTesting delegate;
NotificationManagerForTesting notificationManager(delegate);
NotificationManagerForTesting notificationManager;
eye::MapObject mapObject;
mapObject.SetPos(MercatorBounds::FromLatLon({59.909299, 10.769807}));
@ -287,13 +286,13 @@ UNIT_CLASS_TEST(ScopedNotificationsQueue, Notifications_UgcRateCheckPlannedTripT
TEST(!result.is_initialized(), ());
notificationManager.GetEditableQueue().m_candidates[0].m_created =
notifications::Clock::now() - std::chrono::hours(25);
auto & candidate = notificationManager.GetEditableQueue().m_candidates[0];
NotificationManagerForTesting::SetCreatedTime(candidate, Clock::now() - hours(25));
result = notificationManager.GetNotification();
TEST(result.is_initialized(), ());
TEST_EQUAL(result.get().m_type, NotificationCandidate::Type::UgcReview, ());
TEST_EQUAL(result.get().GetType(), NotificationCandidate::Type::UgcReview, ());
result = notificationManager.GetNotification();
TEST(!result.is_initialized(), ());

41
map/notifications/notification_manager.cpp
View file

@ -104,9 +104,10 @@ bool CheckPlannedTripTrigger(eye::MapObject const & poi)
namespace notifications
{
NotificationManager::NotificationManager(NotificationManager::Delegate & delegate)
: m_delegate(delegate)
void NotificationManager::SetDelegate(std::unique_ptr<Delegate> delegate)
{
m_delegate = std::move(delegate);
}
void NotificationManager::Load()
@ -136,10 +137,10 @@ void NotificationManager::TrimExpired()
candidates.erase(std::remove_if(candidates.begin(), candidates.end(), [](auto const & item)
{
if (item.m_used.time_since_epoch().count() != 0)
return Clock::now() - item.m_used >= eye::Eye::GetMapObjectEventsExpirePeriod();
if (item.IsUsed())
return Clock::now() - item.GetLastUsedTime() >= eye::Eye::GetMapObjectEventsExpirePeriod();
return Clock::now() - item.m_created >= kCandidatesExpirePeriod;
return Clock::now() - item.GetCreatedTime() >= kCandidatesExpirePeriod;
}), candidates.end());
if (sizeBefore != candidates.size())
@ -161,7 +162,7 @@ boost::optional<NotificationCandidate> NotificationManager::GetNotification()
if (it == candidates.end())
return {};
it->m_used = Clock::now();
it->MarkAsUsed();
m_queue.m_lastNotificationProvidedTime = Clock::now();
VERIFY(Save(), ());
@ -176,15 +177,13 @@ size_t NotificationManager::GetCandidatesCount() const
void NotificationManager::OnMapObjectEvent(eye::MapObject const & poi)
{
CHECK(m_delegate.GetUGCApi(), ());
CHECK_GREATER(poi.GetEvents().size(), 0, ());
auto const bestType = classif().GetTypeByReadableObjectName(poi.GetBestType());
if (poi.GetEvents().back().m_type == eye::MapObject::Event::Type::UgcSaved)
return ProcessUgcRateCandidates(poi);
m_delegate.GetUGCApi()->HasUGCForPlace(bestType, poi.GetPos(), [this, poi] (bool result)
auto const bestType = classif().GetTypeByReadableObjectName(poi.GetBestType());
m_delegate->GetUGCApi().HasUGCForPlace(bestType, poi.GetPos(), [this, poi] (bool result)
{
if (!result)
ProcessUgcRateCandidates(poi);
@ -202,16 +201,16 @@ void NotificationManager::ProcessUgcRateCandidates(eye::MapObject const & poi)
{
CHECK_GREATER(poi.GetEvents().size(), 0, ());
if (poi.IsEmpty())
return;
auto it = m_queue.m_candidates.begin();
for (; it != m_queue.m_candidates.end(); ++it)
{
if (it->m_type != NotificationCandidate::Type::UgcReview || !it->m_mapObject ||
it->m_used.time_since_epoch().count() != 0)
{
if (it->GetType() != NotificationCandidate::Type::UgcReview || it->IsUsed())
continue;
}
if (it->m_mapObject->AlmostEquals(poi))
if (it->IsSameMapObject(poi))
{
if (poi.GetEvents().back().m_type == eye::MapObject::Event::Type::UgcSaved)
{
@ -229,12 +228,7 @@ void NotificationManager::ProcessUgcRateCandidates(eye::MapObject const & poi)
if (CheckUgcNotSavedTrigger(poi) || CheckRouteToInSameGeoTrigger(poi) ||
CheckPlannedTripTrigger(poi))
{
NotificationCandidate candidate;
candidate.m_type = NotificationCandidate::Type::UgcReview;
candidate.m_created = Clock::now();
candidate.m_mapObject = std::make_shared<eye::MapObject>(poi);
candidate.m_mapObject->GetEditableEvents().clear();
m_queue.m_candidates.emplace_back(std::move(candidate));
m_queue.m_candidates.emplace_back(poi, m_delegate->GetAddress(poi.GetPos()));
VERIFY(Save(), ());
}
@ -245,9 +239,8 @@ Candidates::iterator NotificationManager::GetUgcRateCandidate()
auto it = m_queue.m_candidates.begin();
for (; it != m_queue.m_candidates.end(); ++it)
{
if (it->m_used.time_since_epoch().count() == 0 &&
it->m_type == NotificationCandidate::Type::UgcReview &&
Clock::now() - it->m_created >= kMinTimeSinceLastEventForUgcRate)
if (!it->IsUsed() && it->GetType() == NotificationCandidate::Type::UgcReview &&
Clock::now() - it->GetCreatedTime() >= kMinTimeSinceLastEventForUgcRate)
{
return it;
}

23
map/notifications/notification_manager.hpp
View file

@ -7,9 +7,11 @@
#include "metrics/eye.hpp"
#include <ctime>
#include <memory>
#include <string>
#include <boost/optional.hpp>
#include <search/reverse_geocoder.hpp>
namespace notifications
{
@ -22,10 +24,11 @@ public:
{
public:
virtual ~Delegate() = default;
virtual ugc::Api * GetUGCApi() = 0;
virtual ugc::Api & GetUGCApi() = 0;
virtual std::string GetAddress(m2::PointD const & pt) = 0;
};
explicit NotificationManager(Delegate & delegate);
void SetDelegate(std::unique_ptr<Delegate> delegate);
void Load();
void TrimExpired();
@ -41,17 +44,18 @@ private:
void ProcessUgcRateCandidates(eye::MapObject const & poi);
Candidates::iterator GetUgcRateCandidate();
Delegate & m_delegate;
std::unique_ptr<Delegate> m_delegate;
// Notification candidates queue.
Queue m_queue;
};
} // namespace notifications
namespace lightweight
{
class NotificationManager
{
public:
NotificationManager() : m_manager(m_delegate) { m_manager.Load(); }
NotificationManager() { m_manager.Load(); }
boost::optional<notifications::NotificationCandidate> GetNotification()
{
@ -65,17 +69,6 @@ public:
}
private:
class EmptyDelegate : public notifications::NotificationManager::Delegate
{
public:
// NotificationManager::Delegate overrides:
ugc::Api * GetUGCApi() override
{
return nullptr;
}
};
EmptyDelegate m_delegate;
notifications::NotificationManager m_manager;
};
} // namespace lightweight

43
map/notifications/notification_manager_delegate.cpp Normal file
View file

@ -0,0 +1,43 @@
#include "notification_manager_delegate.hpp"
#include "ugc/api.hpp"
#include "map/utils.hpp"
#include "search/city_finder.hpp"
#include "indexer/feature_decl.hpp"
#include "platform/preferred_languages.hpp"
#include "coding/string_utf8_multilang.hpp"
namespace notifications
{
NotificationManagerDelegate::NotificationManagerDelegate(DataSource const & dataSource,
search::CityFinder & cityFinder,
ugc::Api & ugcApi)
: m_dataSource(dataSource), m_cityFinder(cityFinder), m_ugcApi(ugcApi)
{
}
ugc::Api & NotificationManagerDelegate::GetUGCApi()
{
return m_ugcApi;
}
string NotificationManagerDelegate::GetAddress(m2::PointD const & pt)
{
auto const address = utils::GetAddressAtPoint(m_dataSource, pt).FormatAddress();
auto const langIndex = StringUtf8Multilang::GetLangIndex(languages::GetCurrentNorm());
auto const city = m_cityFinder.GetCityName(pt, langIndex);
if (address.empty())
return city;
if (city.empty())
return address;
return city + " ," + address;
}
} // namespace notifications

36
map/notifications/notification_manager_delegate.hpp Normal file
View file

@ -0,0 +1,36 @@
#pragma once
#include "map/notifications/notification_manager.hpp"
#include "geometry/point2d.hpp"
class DataSource;
namespace search
{
class CityFinder;
}
namespace ugc
{
class Api;
}
namespace notifications
{
class NotificationManagerDelegate : public NotificationManager::Delegate
{
public:
NotificationManagerDelegate(DataSource const & dataSource, search::CityFinder & cityFinder,
ugc::Api & ugcApi);
// NotificationManager::Delegate overrides:
ugc::Api & GetUGCApi() override;
string GetAddress(m2::PointD const & pt) override;
private:
DataSource const & m_dataSource;
search::CityFinder & m_cityFinder;
ugc::Api & m_ugcApi;
};
}

87
map/notifications/notification_queue.cpp Normal file
View file

@ -0,0 +1,87 @@
#include "map/notifications/notification_queue.hpp"
#include "base/assert.hpp"
namespace notifications
{
NotificationCandidate::NotificationCandidate(eye::MapObject const & poi,
std::string const & address)
: m_type(NotificationCandidate::Type::UgcReview)
, m_created(Clock::now())
, m_mapObject(std::make_shared<eye::MapObject>(poi))
, m_address(address)
{
CHECK(!poi.IsEmpty(), ());
m_mapObject->GetEditableEvents().clear();
}
NotificationCandidate::Type NotificationCandidate::GetType() const
{
return m_type;
}
Time NotificationCandidate::GetCreatedTime() const
{
return m_created;
}
Time NotificationCandidate::GetLastUsedTime() const
{
return m_used;
}
bool NotificationCandidate::IsUsed() const
{
return m_used.time_since_epoch().count() != 0;
}
void NotificationCandidate::MarkAsUsed()
{
CHECK_EQUAL(m_used.time_since_epoch().count(), 0, ());
m_used = Clock::now();
}
bool NotificationCandidate::IsSameMapObject(eye::MapObject const & rhs) const
{
CHECK_EQUAL(m_type, NotificationCandidate::Type::UgcReview, ());
return m_mapObject->AlmostEquals(rhs);
}
std::string const & NotificationCandidate::GetBestFeatureType() const
{
CHECK_EQUAL(m_type, NotificationCandidate::Type::UgcReview, ());
return m_mapObject->GetBestType();
}
m2::PointD const & NotificationCandidate::GetPos() const
{
CHECK_EQUAL(m_type, NotificationCandidate::Type::UgcReview, ());
return m_mapObject->GetPos();
}
std::string const & NotificationCandidate::GetDefaultName() const
{
CHECK_EQUAL(m_type, NotificationCandidate::Type::UgcReview, ());
return m_mapObject->GetDefaultName();
}
std::string const & NotificationCandidate::GetReadableName() const
{
CHECK_EQUAL(m_type, NotificationCandidate::Type::UgcReview, ());
return m_mapObject->GetReadableName();
}
std::string const & NotificationCandidate::GetAddress() const
{
CHECK_EQUAL(m_type, NotificationCandidate::Type::UgcReview, ());
return m_address;
}
} // namespace notifications

30
map/notifications/notification_queue.hpp
View file

@ -11,8 +11,11 @@ namespace notifications
using Clock = std::chrono::system_clock;
using Time = Clock::time_point;
struct NotificationCandidate
class NotificationCandidate
{
public:
friend class NotificationManagerForTesting;
enum class Type : uint8_t
{
UgcAuth = 0,
@ -20,12 +23,35 @@ struct NotificationCandidate
};
DECLARE_VISITOR(visitor(m_type, "type"), visitor(m_created, "created_time"),
visitor(m_used, "used"), visitor(m_mapObject, "object"));
visitor(m_used, "used"), visitor(m_mapObject, "object"),
visitor(m_address, std::string(""), "address"));
NotificationCandidate() = default;
// Constructs candidate with type Type::UgcReview.
NotificationCandidate(eye::MapObject const & poi, std::string const & address);
Type GetType() const;
Time GetCreatedTime() const;
Time GetLastUsedTime() const;
bool IsUsed() const;
void MarkAsUsed();
// Methods for Type::UgcReview type.
// It is possible to use inheritance, but our serialization/deserialization
// mechanism is not support it.
bool IsSameMapObject(eye::MapObject const & rhs) const;
std::string const & GetBestFeatureType() const;
m2::PointD const & GetPos() const;
std::string const & GetDefaultName() const;
std::string const & GetReadableName() const;
std::string const & GetAddress() const;
private:
Type m_type;
Time m_created;
Time m_used;
std::shared_ptr<eye::MapObject> m_mapObject;
std::string m_address;
};
using Candidates = std::deque<NotificationCandidate>;

18
map/utils.cpp
View file

@ -3,6 +3,7 @@
#include "map/place_page_info.hpp"
#include "indexer/feature.hpp"
#include "indexer/feature_decl.hpp"
#include "indexer/feature_algo.hpp"
namespace utils
@ -49,4 +50,21 @@ eye::MapObject MakeEyeMapObject(FeatureType & ft)
return mapObject;
}
search::ReverseGeocoder::Address GetAddressAtPoint(DataSource const & dataSource,
m2::PointD const & pt)
{
double const kDistanceThresholdMeters = 0.5;
search::ReverseGeocoder const coder(dataSource);
search::ReverseGeocoder::Address address;
coder.GetNearbyAddress(pt, address);
// We do not init nearby address info for points that are located
// outside of the nearby building.
if (address.GetDistance() < kDistanceThresholdMeters)
return address;
return {};
}
} // namespace utils

8
map/utils.hpp
View file

@ -1,16 +1,24 @@
#pragma once
#include "search/reverse_geocoder.hpp"
#include "metrics/eye_info.hpp"
#include "geometry/point2d.hpp"
namespace place_page
{
class Info;
}
class DataSource;
class FeatureType;
namespace utils
{
eye::MapObject MakeEyeMapObject(place_page::Info const & info);
eye::MapObject MakeEyeMapObject(FeatureType & ft);
search::ReverseGeocoder::Address GetAddressAtPoint(DataSource const & dataSource,
m2::PointD const & pt);
} // namespace utils