kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

[new downloader] Moving new developed map downloader functionality to new map downloader branch.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2016-02-02 17:31:11 +03:00 • committed by Sergey Yershov
parent de3a5b9df1
commit dbe555605f
44 changed files with 1866 additions and 1112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
drape_frontend/drape_engine.cpp
View file

@ -5,6 +5,8 @@
#include "drape_frontend/gui/country_status_helper.hpp"
#include "drape_frontend/gui/drape_gui.hpp"
#include "storage/index.hpp"
#include "drape/texture_manager.hpp"
#include "platform/platform.hpp"
@ -18,15 +20,15 @@ namespace df
namespace
{
void ConnectDownloadFn(gui::CountryStatusHelper::EButtonType buttonType, MapDataProvider::TDownloadFn downloadFn)
void ConnectDownloadFn(gui::CountryStatusHelper::EButtonType buttonType, TDownloadFn downloadFn)
{
gui::DrapeGui & guiSubsystem = gui::DrapeGui::Instance();
guiSubsystem.ConnectOnButtonPressedHandler(buttonType, [downloadFn, &guiSubsystem]()
{
storage::TIndex countryIndex = guiSubsystem.GetCountryStatusHelper().GetCountryIndex();
ASSERT(countryIndex != storage::TIndex::INVALID, ());
storage::TCountryId countryId = guiSubsystem.GetCountryStatusHelper().GetCountryIndex();
ASSERT(countryId != storage::kInvalidCountryId, ());
if (downloadFn != nullptr)
downloadFn(countryIndex);
downloadFn(countryId);
});
}

2
drape_frontend/gui/country_status_helper.cpp
View file

@ -104,7 +104,7 @@ void CountryStatusHelper::Clear()
SetState(COUNTRY_STATE_LOADED);
}
storage::TIndex CountryStatusHelper::GetCountryIndex() const
storage::TCountryId CountryStatusHelper::GetCountryIndex() const
{
return m_countryInfo.m_countryIndex;
}

4
drape_frontend/gui/country_status_helper.hpp
View file

@ -15,7 +15,7 @@ namespace gui
struct CountryInfo
{
storage::TIndex m_countryIndex = storage::TIndex::INVALID;
storage::TCountryId m_countryIndex = storage::kInvalidCountryId;
storage::TStatus m_countryStatus = storage::TStatus::EUnknown;
string m_currentCountryName;
size_t m_mapSize = 0;
@ -62,7 +62,7 @@ public:
void SetCountryInfo(CountryInfo const & countryInfo);
void Clear();
storage::TIndex GetCountryIndex() const;
storage::TCountryId GetCountryIndex() const;
ECountryState GetState() const;
/// CountryStatusHandle work on FrontendRenderer and call this function to check "is visible"
/// or state has already changed.

10
drape_frontend/map_data_provider.cpp
View file

@ -32,9 +32,9 @@ void MapDataProvider::ReadFeatures(TReadCallback<FeatureType> const & fn, vector
m_featureReader(fn, ids);
}
void MapDataProvider::UpdateCountryIndex(storage::TIndex const & currentIndex, m2::PointF const & pt)
void MapDataProvider::UpdateCountryIndex(storage::TCountryId const & currentId, m2::PointF const & pt)
{
m_countryIndexUpdater(currentIndex, pt);
m_countryIndexUpdater(currentId, pt);
}
MapDataProvider::TIsCountryLoadedFn const & MapDataProvider::GetIsCountryLoadedFn() const
@ -42,17 +42,17 @@ MapDataProvider::TIsCountryLoadedFn const & MapDataProvider::GetIsCountryLoadedF
return m_isCountryLoadedFn;
}
MapDataProvider::TDownloadFn const & MapDataProvider::GetDownloadMapHandler() const
TDownloadFn const & MapDataProvider::GetDownloadMapHandler() const
{
return m_downloadMapHandler;
}
MapDataProvider::TDownloadFn const & MapDataProvider::GetDownloadRetryHandler() const
TDownloadFn const & MapDataProvider::GetDownloadRetryHandler() const
{
return m_downloadRetryHandler;
}
MapDataProvider::TDownloadFn const & MapDataProvider::GetDownloadCancelHandler() const
TDownloadFn const & MapDataProvider::GetDownloadCancelHandler() const
{
return m_downloadCancelHandler;
}

5
drape_frontend/map_data_provider.hpp
View file

@ -17,10 +17,9 @@ public:
template <typename T> using TReadCallback = function<void (T const &)>;
using TReadFeaturesFn = function<void (TReadCallback<FeatureType> const & , vector<FeatureID> const &)>;
using TReadIDsFn = function<void (TReadCallback<FeatureID> const & , m2::RectD const &, int)>;
using TUpdateCountryIndexFn = function<void (storage::TIndex const & , m2::PointF const &)>;
using TUpdateCountryIndexFn = function<void (storage::TCountryId const & , m2::PointF const &)>;
using TIsCountryLoadedFn = function<bool (m2::PointD const &)>;
using TIsCountryLoadedByNameFn = function<bool (string const &)>;
using TDownloadFn = function<void (storage::TIndex const &)>;
MapDataProvider(TReadIDsFn const & idsReader,
TReadFeaturesFn const & featureReader,
@ -34,7 +33,7 @@ public:
void ReadFeaturesID(TReadCallback<FeatureID> const & fn, m2::RectD const & r, int scale) const;
void ReadFeatures(TReadCallback<FeatureType> const & fn, vector<FeatureID> const & ids) const;
void UpdateCountryIndex(storage::TIndex const & currentIndex, m2::PointF const & pt);
void UpdateCountryIndex(storage::TCountryId const & currentId, m2::PointF const & pt);
TIsCountryLoadedFn const & GetIsCountryLoadedFn() const;
TDownloadFn const & GetDownloadMapHandler() const;

2
indexer/index.hpp
View file

@ -40,7 +40,7 @@ public:
inline feature::DataHeader const & GetHeader() const { return m_factory.GetHeader(); }
inline version::MwmVersion const & GetMwmVersion() const { return m_factory.GetMwmVersion(); }
inline string const & GetCountryFileName() const { return m_file.GetCountryFile().GetNameWithoutExt(); }
inline string const & GetCountryFileName() const { return m_file.GetCountryFile().GetName(); }
};
class Index : public MwmSet

4
indexer/mwm_set.cpp
View file

@ -75,7 +75,7 @@ MwmSet::MwmHandle & MwmSet::MwmHandle::operator=(MwmHandle && handle)
MwmSet::MwmId MwmSet::GetMwmIdByCountryFileImpl(CountryFile const & countryFile) const
{
string const & name = countryFile.GetNameWithoutExt();
string const & name = countryFile.GetName();
ASSERT(!name.empty(), ());
auto const it = m_info.find(name);
if (it == m_info.cend() || it->second.empty())
@ -115,7 +115,7 @@ pair<MwmSet::MwmId, MwmSet::RegResult> MwmSet::Register(LocalCountryFile const &
return;
}
string const name = countryFile.GetNameWithoutExt();
string const name = countryFile.GetName();
// Update the status of the mwm with the same version.
if (info->GetVersion() == localFile.GetVersion())
{

125
map/framework.cpp
View file

@ -243,7 +243,8 @@ void Framework::Migrate()
Storage().DeleteAllLocalMaps();
DeregisterAllMaps();
m_model.Clear();
Storage().Migrate();
// @TODO(syershov) Implement it correctly please.
// Storage().Migrate();
InitCountryInfoGetter();
InitSearchEngine();
RegisterAllMaps();
@ -431,7 +432,7 @@ bool Framework::IsWatchFrameRendererInited() const
return m_cpuDrawer != nullptr;
}
void Framework::DeleteCountry(storage::TIndex const & index, MapOptions opt)
void Framework::DeleteCountry(storage::TCountryId const & index, MapOptions opt)
{
switch (opt)
{
@ -444,7 +445,7 @@ void Framework::DeleteCountry(storage::TIndex const & index, MapOptions opt)
// m_model will notify us when latest map file will be deleted via
// OnMapDeregistered call.
if (m_model.DeregisterMap(countryFile))
InvalidateRect(GetCountryBounds(countryFile.GetNameWithoutExt()));
InvalidateRect(GetCountryBounds(countryFile.GetName()));
// TODO (@ldragunov, @gorshenin): rewrite routing session to use MwmHandles. Thus,
// it won' be needed to reset it after maps update.
@ -458,37 +459,28 @@ void Framework::DeleteCountry(storage::TIndex const & index, MapOptions opt)
}
}
void Framework::DownloadCountry(TIndex const & index, MapOptions opt)
void Framework::DownloadCountry(storage::TCountryId const & index, MapOptions opt)
{
m_storage.DownloadCountry(index, opt);
}
TStatus Framework::GetCountryStatus(TIndex const & index) const
TStatus Framework::GetCountryStatus(storage::TCountryId const & index) const
{
return m_storage.CountryStatusEx(index);
}
string Framework::GetCountryName(TIndex const & index) const
string Framework::GetCountryName(storage::TCountryId const & countryId) const
{
string group, name;
m_storage.GetGroupAndCountry(index, group, name);
return (!group.empty() ? group + ", " + name : name);
return countryId;
}
m2::RectD Framework::GetCountryBounds(string const & file) const
m2::RectD Framework::GetCountryBounds(storage::TCountryId const & countryId) const
{
m2::RectD const bounds = m_infoGetter->CalcLimitRect(file);
ASSERT(bounds.IsValid(), ());
return bounds;
CountryFile const & file = m_storage.GetCountryFile(countryId);
return GetCountryBounds(file.GetName());
}
m2::RectD Framework::GetCountryBounds(TIndex const & index) const
{
CountryFile const & file = m_storage.GetCountryFile(index);
return GetCountryBounds(file.GetNameWithoutExt());
}
void Framework::ShowCountry(TIndex const & index)
void Framework::ShowCountry(storage::TCountryId const & index)
{
StopLocationFollow();
@ -530,11 +522,12 @@ void Framework::RegisterAllMaps()
{
bool disableFastMigrate = false;
Settings::Get("DisableFastMigrate", disableFastMigrate);
if (!disableFastMigrate && !m_storage.HaveDownloadedCountries())
{
Migrate();
return;
}
// @TODO(syershov) Implement it correctly please.
// if (!disableFastMigrate && !m_storage.HaveDownloadedCountries())
// {
// Migrate();
// return;
// }
}
int minFormat = numeric_limits<int>::max();
@ -853,7 +846,7 @@ bool Framework::IsCountryLoaded(m2::PointD const & pt) const
// obfuscating and should be fixed.
// Correct, but slow version (check country polygon).
string const fName = m_infoGetter->GetRegionFile(pt);
string const fName = m_infoGetter->GetRegionCountryId(pt);
if (fName.empty())
return true;
@ -912,44 +905,44 @@ void Framework::SetAutoDownloadListener(TAutoDownloadListener const & listener)
m_autoDownloadListener = listener;
}
void Framework::OnDownloadMapCallback(storage::TIndex const & countryIndex)
void Framework::OnDownloadMapCallback(storage::TCountryId const & countryId)
{
}
void Framework::OnDownloadRetryCallback(storage::TIndex const & countryIndex)
void Framework::OnDownloadRetryCallback(storage::TCountryId const & countryId)
{
}
void Framework::OnDownloadCancelCallback(storage::TIndex const & countryIndex)
void Framework::OnDownloadCancelCallback(storage::TCountryId const & countryId)
{
// Any cancel leads to disable auto-downloading.
m_autoDownloadingOn = false;
}
void Framework::OnUpdateCountryIndex(storage::TIndex const & currentIndex, m2::PointF const & pt)
void Framework::OnUpdateCountryIndex(storage::TCountryId const & currentId, m2::PointF const & pt)
{
storage::TIndex newCountryIndex = GetCountryIndex(m2::PointD(pt));
if (!newCountryIndex.IsValid())
storage::TCountryId newCountryId = GetCountryIndex(m2::PointD(pt));
if (newCountryId != storage::kInvalidCountryId)
{
m_drapeEngine->SetInvalidCountryInfo();
return;
}
if (currentIndex != newCountryIndex)
if (currentId != newCountryId)
{
if (m_autoDownloadingOn && m_autoDownloadListener != nullptr)
m_autoDownloadListener(newCountryIndex);
m_autoDownloadListener(newCountryId);
UpdateCountryInfo(newCountryIndex, true /* isCurrentCountry */);
UpdateCountryInfo(newCountryId, true /* isCurrentCountry */);
}
}
void Framework::UpdateCountryInfo(storage::TIndex const & countryIndex, bool isCurrentCountry)
void Framework::UpdateCountryInfo(storage::TCountryId const & countryId, bool isCurrentCountry)
{
if (!m_drapeEngine)
return;
string const & fileName = m_storage.CountryByIndex(countryIndex).GetFile().GetNameWithoutExt();
string const & fileName = countryId;
if (m_model.IsLoaded(fileName))
{
m_drapeEngine->SetInvalidCountryInfo();
@ -958,7 +951,7 @@ void Framework::UpdateCountryInfo(storage::TIndex const & countryIndex, bool isC
gui::CountryInfo countryInfo;
countryInfo.m_countryIndex = countryIndex;
countryInfo.m_countryIndex = countryId;
if (countryInfo.m_countryStatus == storage::TStatus::EDownloading)
countryInfo.m_downloadProgress = 50;
@ -1096,9 +1089,9 @@ void Framework::InitSearchEngine()
}
}
TIndex Framework::GetCountryIndex(m2::PointD const & pt) const
storage::TCountryId Framework::GetCountryIndex(m2::PointD const & pt) const
{
return m_storage.FindIndexByFile(m_infoGetter->GetRegionFile(pt));
return m_infoGetter->GetRegionCountryId(pt);
}
string Framework::GetCountryName(m2::PointD const & pt) const
@ -1108,13 +1101,6 @@ string Framework::GetCountryName(m2::PointD const & pt) const
return info.m_name;
}
string Framework::GetCountryName(string const & id) const
{
storage::CountryInfo info;
m_infoGetter->GetRegionInfo(id, info);
return info.m_name;
}
bool Framework::QueryMayBeSkipped(search::SearchParams const & params,
m2::RectD const & viewport) const
{
@ -1383,7 +1369,6 @@ void Framework::CreateDrapeEngine(ref_ptr<dp::OGLContextFactory> contextFactory,
using TReadFeaturesFn = df::MapDataProvider::TReadFeaturesFn;
using TUpdateCountryIndexFn = df::MapDataProvider::TUpdateCountryIndexFn;
using TIsCountryLoadedFn = df::MapDataProvider::TIsCountryLoadedFn;
using TDownloadFn = df::MapDataProvider::TDownloadFn;
TReadIDsFn idReadFn = [this](df::MapDataProvider::TReadCallback<FeatureID> const & fn, m2::RectD const & r, int scale) -> void
{
@ -1395,27 +1380,27 @@ void Framework::CreateDrapeEngine(ref_ptr<dp::OGLContextFactory> contextFactory,
m_model.ReadFeatures(fn, ids);
};
TUpdateCountryIndexFn updateCountryIndex = [this](storage::TIndex const & currentIndex, m2::PointF const & pt)
TUpdateCountryIndexFn updateCountryIndex = [this](storage::TCountryId const & currentId, m2::PointF const & pt)
{
GetPlatform().RunOnGuiThread(bind(&Framework::OnUpdateCountryIndex, this, currentIndex, pt));
GetPlatform().RunOnGuiThread(bind(&Framework::OnUpdateCountryIndex, this, currentId, pt));
};
TIsCountryLoadedFn isCountryLoadedFn = bind(&Framework::IsCountryLoaded, this, _1);
auto isCountryLoadedByNameFn = bind(&Framework::IsCountryLoadedByName, this, _1);
TDownloadFn downloadMapFn = [this](storage::TIndex const & countryIndex)
TDownloadFn downloadMapFn = [this](storage::TCountryId const & countryId)
{
GetPlatform().RunOnGuiThread(bind(&Framework::OnDownloadMapCallback, this, countryIndex));
GetPlatform().RunOnGuiThread(bind(&Framework::OnDownloadMapCallback, this, countryId));
};
TDownloadFn downloadRetryFn = [this](storage::TIndex const & countryIndex)
TDownloadFn downloadRetryFn = [this](storage::TCountryId const & countryId)
{
GetPlatform().RunOnGuiThread(bind(&Framework::OnDownloadRetryCallback, this, countryIndex));
GetPlatform().RunOnGuiThread(bind(&Framework::OnDownloadRetryCallback, this, countryId));
};
TDownloadFn downloadCancelFn = [this](storage::TIndex const & countryIndex)
TDownloadFn downloadCancelFn = [this](storage::TCountryId const & countryId)
{
GetPlatform().RunOnGuiThread(bind(&Framework::OnDownloadCancelCallback, this, countryIndex));
GetPlatform().RunOnGuiThread(bind(&Framework::OnDownloadCancelCallback, this, countryId));
};
bool allow3d;
@ -1599,13 +1584,6 @@ gui::TWidgetsSizeInfo const & Framework::GetWidgetSizes()
return m_drapeEngine->GetWidgetSizes();
}
string Framework::GetCountryCode(m2::PointD const & pt) const
{
storage::CountryInfo info;
m_infoGetter->GetRegionInfo(pt, info);
return info.m_flag;
}
bool Framework::ShowMapForURL(string const & url)
{
m2::PointD point;
@ -2045,7 +2023,7 @@ void Framework::BuildRoute(m2::PointD const & finish, uint32_t timeoutSec)
m2::PointD start;
if (!m_drapeEngine->GetMyPosition(start))
{
CallRouteBuilded(IRouter::NoCurrentPosition, vector<storage::TIndex>(), vector<storage::TIndex>());
CallRouteBuilded(IRouter::NoCurrentPosition, storage::TCountriesVec(), storage::TCountriesVec());
return;
}
@ -2065,8 +2043,8 @@ void Framework::BuildRoute(m2::PointD const & start, m2::PointD const & finish,
auto readyCallback = [this] (Route const & route, IRouter::ResultCode code)
{
vector<storage::TIndex> absentCountries;
vector<storage::TIndex> absentRoutingIndexes;
storage::TCountriesVec absentCountries;
storage::TCountriesVec absentRoutingIndexes;
if (code == IRouter::NoError)
{
double const kRouteScaleMultiplier = 1.5;
@ -2080,11 +2058,11 @@ void Framework::BuildRoute(m2::PointD const & start, m2::PointD const & finish,
{
for (string const & name : route.GetAbsentCountries())
{
storage::TIndex fileIndex = m_storage.FindIndexByFile(name);
if (m_storage.GetLatestLocalFile(fileIndex))
absentRoutingIndexes.push_back(fileIndex);
storage::TCountryId fileCountryId = name;
if (m_storage.GetLatestLocalFile(fileCountryId))
absentRoutingIndexes.push_back(fileCountryId);
else
absentCountries.push_back(fileIndex);
absentCountries.push_back(fileCountryId);
}
if (code != IRouter::NeedMoreMaps)
@ -2143,7 +2121,7 @@ void Framework::SetRouterImpl(RouterType type)
{
// TODO (@gorshenin): fix CountryInfoGetter to return CountryFile
// instances instead of plain strings.
return m_infoGetter->GetRegionFile(p);
return m_infoGetter->GetRegionCountryId(p);
};
if (type == RouterType::Pedestrian)
@ -2238,7 +2216,8 @@ void Framework::MatchLocationToRoute(location::GpsInfo & location, location::Rou
m_routingSession.MatchLocationToRoute(location, routeMatchingInfo);
}
void Framework::CallRouteBuilded(IRouter::ResultCode code, vector<storage::TIndex> const & absentCountries, vector<storage::TIndex> const & absentRoutingFiles)
void Framework::CallRouteBuilded(IRouter::ResultCode code, storage::TCountriesVec const & absentCountries,
storage::TCountriesVec const & absentRoutingFiles)
{
if (code == IRouter::Cancelled)
return;
@ -2289,7 +2268,7 @@ RouterType Framework::GetBestRouter(m2::PointD const & startPoint, m2::PointD co
// Return on a short distance the vehicle router flag only if we are already have routing files.
auto countryFileGetter = [this](m2::PointD const & pt)
{
return m_infoGetter->GetRegionFile(pt);
return m_infoGetter->GetRegionCountryId(pt);
};
if (!OsrmRouter::CheckRoutingAbility(startPoint, finalPoint, countryFileGetter,
&m_model.GetIndex()))

44
map/framework.hpp
View file

@ -95,9 +95,9 @@ class Framework
protected:
using TDrapeFunction = function<void (df::DrapeEngine *)>;
using TDownloadCountryListener = function<void(storage::TIndex const &, int)>;
using TDownloadCancelListener = function<void(storage::TIndex const &)>;
using TAutoDownloadListener = function<void(storage::TIndex const &)>;
using TDownloadCountryListener = function<void(storage::TCountryId const &, int)>;
using TDownloadCancelListener = function<void(storage::TCountryId const &)>;
using TAutoDownloadListener = function<void(storage::TCountryId const &)>;
StringsBundle m_stringsBundle;
@ -188,23 +188,22 @@ public:
/// @name This functions is used by Downloader UI.
//@{
/// options - flags that signal about parts of map that must be deleted
void DeleteCountry(storage::TIndex const & index, MapOptions opt);
void DeleteCountry(storage::TCountryId const & index, MapOptions opt);
/// options - flags that signal about parts of map that must be downloaded
void DownloadCountry(storage::TIndex const & index, MapOptions opt);
void DownloadCountry(storage::TCountryId const & index, MapOptions opt);
void SetDownloadCountryListener(TDownloadCountryListener const & listener);
void SetDownloadCancelListener(TDownloadCancelListener const & listener);
void SetAutoDownloadListener(TAutoDownloadListener const & listener);
storage::TStatus GetCountryStatus(storage::TIndex const & index) const;
string GetCountryName(storage::TIndex const & index) const;
storage::TStatus GetCountryStatus(storage::TCountryId const & index) const;
string GetCountryName(storage::TCountryId const & index) const;
/// Get country rect from borders (not from mwm file).
/// @param[in] file Pass country file name without extension as an id.
m2::RectD GetCountryBounds(string const & file) const;
m2::RectD GetCountryBounds(storage::TIndex const & index) const;
m2::RectD GetCountryBounds(storage::TCountryId const & countryId) const;
void ShowCountry(storage::TIndex const & index);
void ShowCountry(storage::TCountryId const & index);
/// Checks, whether the country which contains the specified point is loaded.
bool IsCountryLoaded(m2::PointD const & pt) const;
@ -216,14 +215,9 @@ public:
/// @name Get any country info by point.
//@{
storage::TIndex GetCountryIndex(m2::PointD const & pt) const;
storage::TCountryId GetCountryIndex(m2::PointD const & pt) const;
string GetCountryName(m2::PointD const & pt) const;
/// @param[in] id Country file name without an extension.
string GetCountryName(string const & id) const;
/// @return country code in ISO 3166-1 alpha-2 format (two small letters) or empty string
string GetCountryCode(m2::PointD const & pt) const;
//@}
storage::Storage & Storage() { return m_storage; }
@ -363,12 +357,12 @@ private:
void FillSearchResultsMarks(search::Results const & results);
void OnDownloadMapCallback(storage::TIndex const & countryIndex);
void OnDownloadRetryCallback(storage::TIndex const & countryIndex);
void OnDownloadCancelCallback(storage::TIndex const & countryIndex);
void OnDownloadMapCallback(storage::TCountryId const & countryIndex);
void OnDownloadRetryCallback(storage::TCountryId const & countryIndex);
void OnDownloadCancelCallback(storage::TCountryId const & countryIndex);
void OnUpdateCountryIndex(storage::TIndex const & currentIndex, m2::PointF const & pt);
void UpdateCountryInfo(storage::TIndex const & countryIndex, bool isCurrentCountry);
void OnUpdateCountryIndex(storage::TCountryId const & currentIndex, m2::PointF const & pt);
void UpdateCountryInfo(storage::TCountryId const & countryIndex, bool isCurrentCountry);
// Search query params and viewport for the latest search
// query. These fields are used to check whether a new search query
@ -540,8 +534,8 @@ public:
public:
using TRouteBuildingCallback = function<void(routing::IRouter::ResultCode,
vector<storage::TIndex> const &,
vector<storage::TIndex> const &)>;
storage::TCountriesVec const &,
storage::TCountriesVec const &)>;
using TRouteProgressCallback = function<void(float)>;
/// @name Routing mode
@ -607,8 +601,8 @@ private:
void InsertRoute(routing::Route const & route);
void CheckLocationForRouting(location::GpsInfo const & info);
void CallRouteBuilded(routing::IRouter::ResultCode code,
vector<storage::TIndex> const & absentCountries,
vector<storage::TIndex> const & absentRoutingFiles);
storage::TCountriesVec const & absentCountries,
storage::TCountriesVec const & absentRoutingFiles);
void MatchLocationToRoute(location::GpsInfo & info, location::RouteMatchingInfo & routeMatchingInfo) const;
string GetRoutingErrorMessage(routing::IRouter::ResultCode code);

4
pedestrian_routing_tests/pedestrian_routing_tests.cpp
View file

@ -91,7 +91,7 @@ unique_ptr<storage::CountryInfoGetter> CreateCountryInfoGetter()
unique_ptr<routing::IRouter> CreatePedestrianAStarTestRouter(Index & index, storage::CountryInfoGetter & cig)
{
auto UKGetter = [&](m2::PointD const & pt) { return cig.GetRegionFile(pt); };
auto UKGetter = [&](m2::PointD const & pt) { return cig.GetRegionCountryId(pt); };
unique_ptr<routing::IVehicleModelFactory> vehicleModelFactory(new SimplifiedPedestrianModelFactory());
unique_ptr<routing::IRoutingAlgorithm> algorithm(new routing::AStarRoutingAlgorithm());
unique_ptr<routing::IRouter> router(new routing::RoadGraphRouter("test-astar-pedestrian", index, UKGetter, move(vehicleModelFactory), move(algorithm), nullptr));
@ -100,7 +100,7 @@ unique_ptr<routing::IRouter> CreatePedestrianAStarTestRouter(Index & index, stor
unique_ptr<routing::IRouter> CreatePedestrianAStarBidirectionalTestRouter(Index & index, storage::CountryInfoGetter & cig)
{
auto UKGetter = [&](m2::PointD const & pt) { return cig.GetRegionFile(pt); };
auto UKGetter = [&](m2::PointD const & pt) { return cig.GetRegionCountryId(pt); };
unique_ptr<routing::IVehicleModelFactory> vehicleModelFactory(new SimplifiedPedestrianModelFactory());
unique_ptr<routing::IRoutingAlgorithm> algorithm(new routing::AStarBidirectionalRoutingAlgorithm());
unique_ptr<routing::IRouter> router(new routing::RoadGraphRouter("test-astar-bidirectional-pedestrian", index, UKGetter, move(vehicleModelFactory), move(algorithm), nullptr));

2
pedestrian_routing_tests/pedestrian_routing_tests.pro
View file

@ -5,7 +5,7 @@ TEMPLATE = app
ROOT_DIR = ../
DEPENDENCIES = map routing search storage indexer platform editor geometry coding base \
osrm jansson protobuf tomcrypt succinct pugixml
osrm jansson protobuf tomcrypt stats_client succinct pugixml
macx-*: LIBS *= "-framework IOKit"

46
platform/country_file.cpp
View file

@ -1,30 +1,39 @@
#include "platform/country_file.hpp"
#include "platform/mwm_version.hpp"
#include "defines.hpp"
#include "base/assert.hpp"
#include "std/sstream.hpp"
namespace
{
/// \returns file name (m_name) with extension dependent on the file param.
/// The extension could be .mwm.routing or just .mwm.
/// The method is used for old (two components) mwm support.
string GetNameWithExt(string const & countryFile, MapOptions file)
{
switch (file)
{
case MapOptions::Map:
return countryFile + DATA_FILE_EXTENSION;
case MapOptions::CarRouting:
return countryFile + DATA_FILE_EXTENSION + ROUTING_FILE_EXTENSION;
default:
ASSERT(false, ("Can't get name for:", file));
return string();
}
}
} // namespace
namespace platform
{
CountryFile::CountryFile() : m_mapSize(0), m_routingSize(0) {}
CountryFile::CountryFile(string const & name) : m_name(name), m_mapSize(0), m_routingSize(0) {}
string const & CountryFile::GetNameWithoutExt() const { return m_name; }
string CountryFile::GetNameWithExt(MapOptions file) const
{
switch (file)
{
case MapOptions::Map:
return m_name + DATA_FILE_EXTENSION;
case MapOptions::CarRouting:
return m_name + DATA_FILE_EXTENSION + ROUTING_FILE_EXTENSION;
default:
ASSERT(false, ("Can't get name for:", file));
return string();
}
}
string const & CountryFile::GetName() const { return m_name; }
void CountryFile::SetRemoteSizes(uint32_t mapSize, uint32_t routingSize)
{
@ -42,6 +51,13 @@ uint32_t CountryFile::GetRemoteSize(MapOptions filesMask) const
return size;
}
string GetFileName(string const & countryFile, MapOptions opt, int64_t version)
{
return version::IsSingleMwm(version) ? GetNameWithExt(countryFile, MapOptions::Map)
: GetNameWithExt(countryFile, opt);
}
string DebugPrint(CountryFile const & file)
{
ostringstream os;

25
platform/country_file.hpp
View file

@ -5,22 +5,23 @@
namespace platform
{
// This class represents a country file name and sizes of
// corresponding map files on a server, which should correspond to an
// entry in countries.txt file. Also, this class can be used to
// represent a hand-made-country name. Instances of this class don't
// represent paths to disk files.
/// This class represents a country file name and sizes of
/// corresponding map files on a server, which should correspond to an
/// entry in countries.txt file. Also, this class can be used to
/// represent a hand-made-country name. Instances of this class don't
/// represent paths to disk files.
class CountryFile
{
public:
CountryFile();
explicit CountryFile(string const & name);
string const & GetNameWithoutExt() const;
string GetNameWithExt(MapOptions file) const;
/// \returns file name without extensions.
string const & GetName() const;
/// \note Remote size is size of mwm in bytes. This mwm contains routing and map sections.
void SetRemoteSizes(uint32_t mapSize, uint32_t routingSize);
uint32_t GetRemoteSize(MapOptions filesMask) const;
uint32_t GetRemoteSize(MapOptions file) const;
inline bool operator<(const CountryFile & rhs) const { return m_name < rhs.m_name; }
inline bool operator==(const CountryFile & rhs) const { return m_name == rhs.m_name; }
@ -29,11 +30,17 @@ public:
private:
friend string DebugPrint(CountryFile const & file);
// Base name (without any extensions) of the file. Same as id of country/region.
/// Base name (without any extensions) of the file. Same as id of country/region.
string m_name;
uint32_t m_mapSize;
uint32_t m_routingSize;
};
/// \returns This method returns file name with extension. For example Abkhazia.mwm or
/// Abkhazia.mwm.routing.
/// \param countryFile is a file name without extension. For example Abkhazia.
/// \param file is type of map data.
/// \param version is version of mwm. For example 160731.
string GetFileName(string const & countryFile, MapOptions file, int64_t version);
string DebugPrint(CountryFile const & file);
} // namespace platform

6
platform/local_country_file.cpp
View file

@ -61,11 +61,7 @@ void LocalCountryFile::DeleteFromDisk(MapOptions files) const
string LocalCountryFile::GetPath(MapOptions file) const
{
// todo(@m): Refactor with MwmTraits after merge new-search branch.
bool const singleFile = version::IsSingleMwm(GetVersion());
string const & countryFilePath = singleFile ? m_countryFile.GetNameWithExt(MapOptions::Map)
: m_countryFile.GetNameWithExt(file);
return my::JoinFoldersToPath(m_directory, countryFilePath);
return my::JoinFoldersToPath(m_directory, GetFileName(m_countryFile.GetName(), file, GetVersion()));
}
uint32_t LocalCountryFile::GetSize(MapOptions filesMask) const

8
platform/local_country_file.hpp
View file

@ -62,7 +62,7 @@ public:
}
inline string const & GetDirectory() const { return m_directory; }
inline string const & GetCountryName() const { return m_countryFile.GetNameWithoutExt(); }
inline string const & GetCountryName() const { return m_countryFile.GetName(); }
inline int64_t GetVersion() const { return m_version; }
inline CountryFile const & GetCountryFile() const { return m_countryFile; }
@ -82,7 +82,7 @@ private:
friend string DebugPrint(LocalCountryFile const &);
friend void UnitTest_LocalCountryFile_DirectoryLookup();
friend void FindAllLocalMapsAndCleanup(int64_t latestVersion,
vector<LocalCountryFile> & localFiles);
string const & dataDir, vector<LocalCountryFile> & localFiles);
/// @note! If directory is empty, the file is stored in resources.
/// In this case, the only valid params are m_countryFile and m_version.
@ -92,7 +92,11 @@ private:
MapOptions m_files;
/// Size of file which contains map section in bytes. It's mwm file in any case.
uint64_t m_mapSize;
/// Size of file which contains routing section in bytes.
/// It's .mwm.routing file in case of big (two component) mwms.
/// And m_routingSize == 0 for small (one compontent) mwms.
uint64_t m_routingSize;
};

64
platform/local_country_file_utils.cpp
View file

@ -131,13 +131,26 @@ bool DirectoryHasIndexesOnly(string const & directory)
}
return true;
}
inline string GetDataDirFullPath(string const & dataDir)
{
Platform & platform = GetPlatform();
return dataDir.empty() ? platform.WritableDir()
: my::JoinFoldersToPath(platform.WritableDir(), dataDir);
}
} // namespace
void DeleteDownloaderFilesForCountry(CountryFile const & countryFile, int64_t version)
void DeleteDownloaderFilesForCountry(int64_t version, CountryFile const & countryFile)
{
DeleteDownloaderFilesForCountry(version, string(), countryFile);
}
void DeleteDownloaderFilesForCountry(int64_t version, string const & dataDir,
CountryFile const & countryFile)
{
for (MapOptions file : {MapOptions::Map, MapOptions::CarRouting})
{
string const path = GetFileDownloadPath(countryFile, file, version);
string const path = GetFileDownloadPath(version, dataDir, countryFile, file);
ASSERT(strings::EndsWith(path, READY_FILE_EXTENSION), ());
my::DeleteFileX(path);
my::DeleteFileX(path + RESUME_FILE_EXTENSION);
@ -213,9 +226,13 @@ void FindAllLocalMapsInDirectoryAndCleanup(string const & directory, int64_t ver
void FindAllLocalMapsAndCleanup(int64_t latestVersion, vector<LocalCountryFile> & localFiles)
{
Platform & platform = GetPlatform();
FindAllLocalMapsAndCleanup(latestVersion, string(), localFiles);
}
string const dir = platform.WritableDir();
void FindAllLocalMapsAndCleanup(int64_t latestVersion, string const & dataDir,
vector<LocalCountryFile> & localFiles)
{
string const dir = GetDataDirFullPath(dataDir);
FindAllLocalMapsInDirectoryAndCleanup(dir, 0 /* version */, latestVersion, localFiles);
Platform::TFilesWithType fwts;
@ -237,17 +254,18 @@ void FindAllLocalMapsAndCleanup(int64_t latestVersion, vector<LocalCountryFile>
// World and WorldCoasts can be stored in app bundle or in resources
// directory, thus it's better to get them via Platform.
for (string const & file : { WORLD_FILE_NAME,
(migrate::NeedMigrate() ? WORLD_COASTS_FILE_NAME : WORLD_COASTS_MIGRATE_FILE_NAME) })
(migrate::NeedMigrate() ? WORLD_COASTS_FILE_NAME : WORLD_COASTS_MIGRATE_FILE_NAME) })
{
auto i = localFiles.begin();
for (; i != localFiles.end(); ++i)
{
if (i->GetCountryFile().GetNameWithoutExt() == file)
if (i->GetCountryFile().GetName() == file)
break;
}
try
{
Platform & platform = GetPlatform();
ModelReaderPtr reader(
platform.GetReader(file + DATA_FILE_EXTENSION, GetSpecialFilesSearchScope()));
@ -296,26 +314,36 @@ bool ParseVersion(string const & s, int64_t & version)
return true;
}
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(CountryFile const & countryFile,
int64_t version)
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(int64_t version, CountryFile const & countryFile)
{
Platform & platform = GetPlatform();
return PreparePlaceForCountryFiles(version, string(), countryFile);
}
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(int64_t version, string const & dataDir,
CountryFile const & countryFile)
{
string const dir = GetDataDirFullPath(dataDir);
if (version == 0)
return make_shared<LocalCountryFile>(platform.WritableDir(), countryFile, version);
string const directory =
my::JoinFoldersToPath(platform.WritableDir(), strings::to_string(version));
return make_shared<LocalCountryFile>(dir, countryFile, version);
string const directory = my::JoinFoldersToPath(dir, strings::to_string(version));
if (!MkDirChecked(directory))
return shared_ptr<LocalCountryFile>();
return make_shared<LocalCountryFile>(directory, countryFile, version);
}
string GetFileDownloadPath(CountryFile const & countryFile, MapOptions file, int64_t version)
string GetFileDownloadPath(int64_t version, CountryFile const & countryFile, MapOptions file)
{
Platform & platform = GetPlatform();
string const readyFile = countryFile.GetNameWithExt(file) + READY_FILE_EXTENSION;
return GetFileDownloadPath(version, string(), countryFile, file);
}
string GetFileDownloadPath(int64_t version, string const & dataDir,
CountryFile const & countryFile, MapOptions file)
{
string const readyFile = GetFileName(countryFile.GetName(), file, version) + READY_FILE_EXTENSION;
string const dir = GetDataDirFullPath(dataDir);
if (version == 0)
return my::JoinFoldersToPath(platform.WritableDir(), readyFile);
return my::JoinFoldersToPath({platform.WritableDir(), strings::to_string(version)}, readyFile);
return my::JoinFoldersToPath(dir, readyFile);
return my::JoinFoldersToPath({dir, strings::to_string(version)}, readyFile);
}
ModelReader * GetCountryReader(platform::LocalCountryFile const & file, MapOptions options)
@ -416,7 +444,7 @@ string CountryIndexes::IndexesDir(LocalCountryFile const & localFile)
MYTHROW(FileSystemException, ("Can't create directory", dir));
}
return my::JoinFoldersToPath(dir, file.GetNameWithoutExt());
return my::JoinFoldersToPath(dir, file.GetName());
}
string DebugPrint(CountryIndexes::Index index)

23
platform/local_country_file_utils.hpp
View file

@ -20,7 +20,11 @@ void SetMigrationFlag();
}
// Removes all files downloader creates during downloading of a country.
void DeleteDownloaderFilesForCountry(CountryFile const & countryFile, int64_t version);
// Note. The the maps are deleted from writable dir/|dataDir|/|version| directory.
// If |dataDir| is empty (or is not set) the function deletes maps from writable dir.
void DeleteDownloaderFilesForCountry(int64_t version, CountryFile const & countryFile);
void DeleteDownloaderFilesForCountry(int64_t version, string const & dataDir,
CountryFile const & countryFile);
// Finds all local map files in |directory|. Version of these files is
// passed as an argument. Also, performs cleanup described in comment
@ -44,7 +48,11 @@ void FindAllLocalMapsInDirectoryAndCleanup(string const & directory, int64_t ver
//
// Also, this method performs cleanup described in a comment for
// CleanupMapsDirectory().
// Note. The the maps are looked for writable dir/|dataDir|/|version| directory.
// If |dataDir| is empty (or is not set) the function looks for maps in writable dir.
void FindAllLocalMapsAndCleanup(int64_t latestVersion, vector<LocalCountryFile> & localFiles);
void FindAllLocalMapsAndCleanup(int64_t latestVersion, string const & dataDir,
vector<LocalCountryFile> & localFiles);
// This method removes:
// * partially downloaded non-latest maps (with version less than |latestVersion|)
@ -61,10 +69,17 @@ bool ParseVersion(string const & s, int64_t & version);
// When version is zero, uses writable directory, otherwise, creates
// directory with name equal to decimal representation of version.
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(CountryFile const & countryFile,
int64_t version);
// Note. The function assumes the maps are located in writable dir/|dataDir|/|version| directory.
// If |dataDir| is empty (or is not set) the function assumes that maps are in writable dir.
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(int64_t version, CountryFile const & countryFile);
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(int64_t version, string const & dataDir,
CountryFile const & countryFile);
string GetFileDownloadPath(CountryFile const & countryFile, MapOptions file, int64_t version);
// Note. The function assumes the maps are located in writable dir/|dataDir|/|version| directory.
// If |dataDir| is empty (or is not set) the function assumes that maps are in writable dir.
string GetFileDownloadPath(int64_t version, CountryFile const & countryFile, MapOptions file);
string GetFileDownloadPath(int64_t version, string const & dataDir,
CountryFile const & countryFile, MapOptions file);
ModelReader * GetCountryReader(LocalCountryFile const & file, MapOptions options);

37
platform/platform_tests/country_file_tests.cpp
View file

@ -1,17 +1,22 @@
#include "testing/testing.hpp"
#include "defines.hpp"
#include "platform/mwm_version.hpp"
#include "platform/country_file.hpp"
namespace platform
{
UNIT_TEST(CountryFile_Smoke)
UNIT_TEST(CountryFile_SmokeTwoComponentMwm)
{
CountryFile countryFile("TestCountry");
TEST_EQUAL("TestCountry", countryFile.GetNameWithoutExt(), ());
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION, countryFile.GetNameWithExt(MapOptions::Map), ());
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION ROUTING_FILE_EXTENSION,
countryFile.GetNameWithExt(MapOptions::CarRouting), ());
TEST_EQUAL("TestCountry", countryFile.GetName(), ());
string const mapFileName = GetFileName(countryFile.GetName(), MapOptions::Map,
version::FOR_TESTING_TWO_COMPONENT_MWM1);
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION, mapFileName, ());
string const routingFileName = GetFileName(countryFile.GetName(), MapOptions::CarRouting,
version::FOR_TESTING_TWO_COMPONENT_MWM1);
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION ROUTING_FILE_EXTENSION, routingFileName, ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::Nothing), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::Map), ());
@ -25,4 +30,26 @@ UNIT_TEST(CountryFile_Smoke)
TEST_EQUAL(2, countryFile.GetRemoteSize(MapOptions::CarRouting), ());
TEST_EQUAL(3, countryFile.GetRemoteSize(MapOptions::MapWithCarRouting), ());
}
UNIT_TEST(CountryFile_SmokeOneComponentMwm)
{
CountryFile countryFile("TestCountryOneComponent");
TEST_EQUAL("TestCountryOneComponent", countryFile.GetName(), ());
string const mapFileName = GetFileName(countryFile.GetName(), MapOptions::MapWithCarRouting,
version::FOR_TESTING_SINGLE_MWM1);
TEST_EQUAL("TestCountryOneComponent" DATA_FILE_EXTENSION, mapFileName, ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::Nothing), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::Map), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::CarRouting), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::MapWithCarRouting), ());
countryFile.SetRemoteSizes(3 /* mapSize */, 0 /* routingSize */);
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::Nothing), ());
TEST_EQUAL(3, countryFile.GetRemoteSize(MapOptions::Map), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(MapOptions::CarRouting), ());
TEST_EQUAL(3, countryFile.GetRemoteSize(MapOptions::MapWithCarRouting), ());
}
} // namespace platform

46
platform/platform_tests/local_country_file_tests.cpp
View file

@ -103,29 +103,26 @@ UNIT_TEST(LocalCountryFile_DiskFiles)
CountryFile countryFile("TestCountry");
countryFile.SetRemoteSizes(1 /* mapSize */, 2 /* routingSize */);
LocalCountryFile localFile(platform.WritableDir(), countryFile, 0 /* version */);
TEST(!localFile.OnDisk(MapOptions::Map), ());
TEST(!localFile.OnDisk(MapOptions::CarRouting), ());
TEST(!localFile.OnDisk(MapOptions::MapWithCarRouting), ());
ScopedFile testMapFile(countryFile.GetNameWithExt(MapOptions::Map), "map");
localFile.SyncWithDisk();
if (version::IsSingleMwm(localFile.GetVersion()))
{
TEST(localFile.OnDisk(MapOptions::Map), ());
TEST(localFile.OnDisk(MapOptions::CarRouting), ());
TEST(localFile.OnDisk(MapOptions::MapWithCarRouting), ());
TEST_EQUAL(3, localFile.GetSize(MapOptions::Map), ());
}
else
for (int64_t version : {1, 150312})
{
LocalCountryFile localFile(platform.WritableDir(), countryFile, version);
TEST(!localFile.OnDisk(MapOptions::Map), ());
TEST(!localFile.OnDisk(MapOptions::CarRouting), ());
TEST(!localFile.OnDisk(MapOptions::MapWithCarRouting), ());
string const mapFileName = GetFileName(countryFile.GetName(), MapOptions::Map,
version::FOR_TESTING_TWO_COMPONENT_MWM1);
ScopedFile testMapFile(mapFileName, "map");
localFile.SyncWithDisk();
TEST(localFile.OnDisk(MapOptions::Map), ());
TEST(!localFile.OnDisk(MapOptions::CarRouting), ());
TEST(!localFile.OnDisk(MapOptions::MapWithCarRouting), ());
TEST_EQUAL(3, localFile.GetSize(MapOptions::Map), ());
ScopedFile testRoutingFile(countryFile.GetNameWithExt(MapOptions::CarRouting), "routing");
string const routingFileName = GetFileName(countryFile.GetName(), MapOptions::CarRouting,
version::FOR_TESTING_TWO_COMPONENT_MWM1);
ScopedFile testRoutingFile(routingFileName, "routing");
localFile.SyncWithDisk();
TEST(localFile.OnDisk(MapOptions::Map), ());
@ -135,14 +132,13 @@ UNIT_TEST(LocalCountryFile_DiskFiles)
TEST_EQUAL(7, localFile.GetSize(MapOptions::CarRouting), ());
TEST_EQUAL(10, localFile.GetSize(MapOptions::MapWithCarRouting), ());
localFile.DeleteFromDisk(MapOptions::MapWithCarRouting);
TEST(!testMapFile.Exists(), (testMapFile, "wasn't deleted by LocalCountryFile."));
testMapFile.Reset();
TEST(!testRoutingFile.Exists(), (testRoutingFile, "wasn't deleted by LocalCountryFile."));
testRoutingFile.Reset();
}
localFile.DeleteFromDisk(MapOptions::MapWithCarRouting);
TEST(!testMapFile.Exists(), (testMapFile, "wasn't deleted by LocalCountryFile."));
testMapFile.Reset();
}
UNIT_TEST(LocalCountryFile_CleanupMapFiles)
@ -319,7 +315,7 @@ UNIT_TEST(LocalCountryFile_PreparePlaceForCountryFiles)
CountryFile italyFile("Italy");
LocalCountryFile expectedItalyFile(platform.WritableDir(), italyFile, 0 /* version */);
shared_ptr<LocalCountryFile> italyLocalFile =
PreparePlaceForCountryFiles(italyFile, 0 /* version */);
PreparePlaceForCountryFiles(0 /* version */, italyFile);
TEST(italyLocalFile.get(), ());
TEST_EQUAL(expectedItalyFile, *italyLocalFile, ());
@ -328,14 +324,14 @@ UNIT_TEST(LocalCountryFile_PreparePlaceForCountryFiles)
CountryFile germanyFile("Germany");
LocalCountryFile expectedGermanyFile(directoryForV1.GetFullPath(), germanyFile, 1 /* version */);
shared_ptr<LocalCountryFile> germanyLocalFile =
PreparePlaceForCountryFiles(germanyFile, 1 /* version */);
PreparePlaceForCountryFiles(1 /* version */, germanyFile);
TEST(germanyLocalFile.get(), ());
TEST_EQUAL(expectedGermanyFile, *germanyLocalFile, ());
CountryFile franceFile("France");
LocalCountryFile expectedFranceFile(directoryForV1.GetFullPath(), franceFile, 1 /* version */);
shared_ptr<LocalCountryFile> franceLocalFile =
PreparePlaceForCountryFiles(franceFile, 1 /* version */);
PreparePlaceForCountryFiles(1 /* version */, franceFile);
TEST(franceLocalFile.get(), ());
TEST_EQUAL(expectedFranceFile, *franceLocalFile, ());
}
@ -347,7 +343,7 @@ UNIT_TEST(LocalCountryFile_CountryIndexes)
CountryFile germanyFile("Germany");
LocalCountryFile germanyLocalFile(testDir.GetFullPath(), germanyFile, 101010 /* version */);
TEST_EQUAL(
my::JoinFoldersToPath(germanyLocalFile.GetDirectory(), germanyFile.GetNameWithoutExt()),
my::JoinFoldersToPath(germanyLocalFile.GetDirectory(), germanyFile.GetName()),
CountryIndexes::IndexesDir(germanyLocalFile), ());
CountryIndexes::PreparePlaceOnDisk(germanyLocalFile);

6
platform/platform_tests_support/scoped_file.cpp
View file

@ -3,6 +3,7 @@
#include "testing/testing.hpp"
#include "platform/country_file.hpp"
#include "platform/mwm_version.hpp"
#include "platform/platform_tests_support/scoped_dir.hpp"
#include "coding/file_name_utils.hpp"
@ -29,8 +30,9 @@ ScopedFile::ScopedFile(string const & relativePath, string const & contents)
ScopedFile::ScopedFile(ScopedDir const & dir, CountryFile const & countryFile, MapOptions file,
string const & contents)
: ScopedFile(my::JoinFoldersToPath(dir.GetRelativePath(), countryFile.GetNameWithExt(file)),
contents)
: ScopedFile(my::JoinFoldersToPath(dir.GetRelativePath(),
GetFileName(countryFile.GetName(), file, version::FOR_TESTING_TWO_COMPONENT_MWM1)),
contents)
{
}

6
qt/draw_widget.cpp
View file

@ -7,6 +7,8 @@
#include "search/result.hpp"
#include "storage/index.hpp"
#include "platform/settings.hpp"
#include "platform/platform.hpp"
#include "platform/settings.hpp"
@ -92,8 +94,8 @@ DrawWidget::DrawWidget(QWidget * parent)
});
m_framework->SetRouteBuildingListener([](routing::IRouter::ResultCode,
vector<storage::TIndex> const &,
vector<storage::TIndex> const &)
storage::TCountriesVec const &,
storage::TCountriesVec const &)
{
});

105
qt/update_dialog.cpp
View file

@ -111,25 +111,9 @@ namespace qt
/// when user clicks on any map row in the table
void UpdateDialog::OnItemClick(QTreeWidgetItem * item, int /*column*/)
{
// calculate index of clicked item
QList<int> treeIndex;
{
QTreeWidgetItem * parent = item;
while (parent)
{
treeIndex.insert(0, parent->data(KColumnIndexCountry, Qt::UserRole).toInt());
parent = parent->parent();
}
while (treeIndex.size() < 3)
treeIndex.append(TIndex::INVALID);
}
TIndex const countryIndex(treeIndex[0], treeIndex[1], treeIndex[2]);
Storage & st = GetStorage();
// skip group items
if (st.CountriesCount(countryIndex) > 0)
return;
// @TODO(bykoianko) Implement when an end user clicks on the map.
// If the map has been downloaded ask if he wants to delete it.
// If It hasn't been just download it.
}
QTreeWidgetItem * MatchedItem(QTreeWidgetItem & parent, int index)
@ -146,28 +130,11 @@ namespace qt
return NULL;
}
/// @return can be null if index is invalid
QTreeWidgetItem * GetTreeItemByIndex(QTreeWidget & tree, TIndex const & index)
/// @return can be null if countryId is invalid
QTreeWidgetItem * GetTreeItemByIndex(QTreeWidget & tree, TCountryId const & countryId)
{
QTreeWidgetItem * item = 0;
if (index.m_group >= 0)
{
for (int i = 0; i < tree.topLevelItemCount(); ++i)
{
QTreeWidgetItem * grItem = tree.topLevelItem(i);
if (index.m_group == grItem->data(KColumnIndexCountry, Qt::UserRole).toInt())
{
item = grItem;
break;
}
}
}
if (item && index.m_country >= 0)
{
item = MatchedItem(*item, index.m_country);
if (item && index.m_region >= 0)
item = MatchedItem(*item, index.m_region);
}
// @TODO(bykoianko) With the help of MatchedItem find item in tree by countryId.
return item;
}
@ -183,9 +150,9 @@ namespace qt
item.setTextColor(column, color);
}
void UpdateDialog::UpdateRowWithCountryInfo(TIndex const & index)
void UpdateDialog::UpdateRowWithCountryInfo(TCountryId const & countryId)
{
QTreeWidgetItem * item = GetTreeItemByIndex(*m_tree, index);
QTreeWidgetItem * item = GetTreeItemByIndex(*m_tree, countryId);
if (item)
{
QColor rowColor;
@ -195,13 +162,13 @@ namespace qt
MapOptions const options = MapOptions::MapWithCarRouting;
Storage const & st = GetStorage();
switch (m_framework.GetCountryStatus(index))
switch (m_framework.GetCountryStatus(countryId))
{
case TStatus::ENotDownloaded:
if (st.CountriesCount(index) == 0)
if (st.CountriesCount(countryId) == 0)
{
size = st.CountrySizeInBytes(index, options);
ASSERT(size.second > 0, (index));
size = st.CountrySizeInBytes(countryId, options);
ASSERT(size.second > 0, (countryId));
statusString = tr("Click to download");
}
rowColor = COLOR_NOTDOWNLOADED;
@ -210,19 +177,19 @@ namespace qt
case TStatus::EOnDisk:
statusString = tr("Installed (click to delete)");
rowColor = COLOR_ONDISK;
size = st.CountrySizeInBytes(index, options);
size = st.CountrySizeInBytes(countryId, options);
break;
case TStatus::EOnDiskOutOfDate:
statusString = tr("Out of date (click to update or delete)");
rowColor = COLOR_OUTOFDATE;
size = st.CountrySizeInBytes(index, options);
size = st.CountrySizeInBytes(countryId, options);
break;
case TStatus::EDownloadFailed:
statusString = tr("Download has failed");
rowColor = COLOR_DOWNLOADFAILED;
size = st.CountrySizeInBytes(index, options);
size = st.CountrySizeInBytes(countryId, options);
break;
case TStatus::EDownloading:
@ -233,7 +200,7 @@ namespace qt
case TStatus::EInQueue:
statusString = tr("Marked for download");
rowColor = COLOR_INQUEUE;
size = st.CountrySizeInBytes(index, options);
size = st.CountrySizeInBytes(countryId, options);
break;
default:
@ -270,9 +237,9 @@ namespace qt
}
}
QTreeWidgetItem * UpdateDialog::CreateTreeItem(TIndex const & index, int value, QTreeWidgetItem * parent)
QTreeWidgetItem * UpdateDialog::CreateTreeItem(TCountryId const & countryId, int value, QTreeWidgetItem * parent)
{
QString const text = QString::fromUtf8(GetStorage().CountryName(index).c_str());
QString const text = QString::fromUtf8(GetStorage().CountryName(countryId).c_str());
QTreeWidgetItem * item = new QTreeWidgetItem(parent, QStringList(text));
item->setData(KColumnIndexCountry, Qt::UserRole, QVariant(value));
@ -281,9 +248,9 @@ namespace qt
return item;
}
int UpdateDialog::GetChildsCount(TIndex const & index) const
int UpdateDialog::GetChildsCount(TCountryId const & countryId) const
{
return static_cast<int>(GetStorage().CountriesCount(index));
return static_cast<int>(GetStorage().CountriesCount(countryId));
}
void UpdateDialog::FillTree()
@ -291,29 +258,7 @@ namespace qt
m_tree->setSortingEnabled(false);
m_tree->clear();
int const gCount = GetChildsCount(TIndex());
for (int group = 0; group < gCount; ++group)
{
TIndex const grIndex(group);
QTreeWidgetItem * groupItem = CreateTreeItem(grIndex, group, 0);
UpdateRowWithCountryInfo(grIndex);
int const cCount = GetChildsCount(grIndex);
for (int country = 0; country < cCount; ++country)
{
TIndex const cIndex(group, country);
QTreeWidgetItem * countryItem = CreateTreeItem(cIndex, country, groupItem);
UpdateRowWithCountryInfo(cIndex);
int const rCount = GetChildsCount(cIndex);
for (int region = 0; region < rCount; ++region)
{
TIndex const rIndex(group, country, region);
(void)CreateTreeItem(rIndex, region, countryItem);
UpdateRowWithCountryInfo(rIndex);
}
}
}
// @TODO(bykoianko) Fill m_tree. Use UpdateRowWithCountryInfo for it.
m_tree->sortByColumn(KColumnIndexCountry, Qt::AscendingOrder);
m_tree->setSortingEnabled(true);
@ -326,15 +271,15 @@ namespace qt
#endif
}
void UpdateDialog::OnCountryChanged(TIndex const & index)
void UpdateDialog::OnCountryChanged(TCountryId const & countryId)
{
UpdateRowWithCountryInfo(index);
UpdateRowWithCountryInfo(countryId);
}
void UpdateDialog::OnCountryDownloadProgress(TIndex const & index,
void UpdateDialog::OnCountryDownloadProgress(TCountryId const & countryId,
pair<int64_t, int64_t> const & progress)
{
QTreeWidgetItem * item = GetTreeItemByIndex(*m_tree, index);
QTreeWidgetItem * item = GetTreeItemByIndex(*m_tree, countryId);
if (item)
item->setText(KColumnIndexSize, QString("%1%").arg(progress.first * 100 / progress.second));
}

10
qt/update_dialog.hpp
View file

@ -27,8 +27,8 @@ namespace qt
/// @name Called from downloader to notify GUI
//@{
void OnCountryChanged(storage::TIndex const & index);
void OnCountryDownloadProgress(storage::TIndex const & index,
void OnCountryChanged(storage::TCountryId const & countryId);
void OnCountryDownloadProgress(storage::TCountryId const & countryId,
pair<int64_t, int64_t> const & progress);
//@}
@ -40,10 +40,10 @@ namespace qt
private:
void FillTree();
void UpdateRowWithCountryInfo(storage::TIndex const & index);
void UpdateRowWithCountryInfo(storage::TCountryId const & countryId);
QTreeWidgetItem * CreateTreeItem(storage::TIndex const & index, int value, QTreeWidgetItem * parent);
int GetChildsCount(storage::TIndex const & index) const;
QTreeWidgetItem * CreateTreeItem(storage::TCountryId const & countryId, int value, QTreeWidgetItem * parent);
int GetChildsCount(storage::TCountryId const & countryId) const;
private:
inline storage::Storage & GetStorage() const { return m_framework.Storage(); }

8
routing/routing_integration_tests/routing_test_tools.cpp
View file

@ -76,7 +76,7 @@ namespace integration
shared_ptr<OsrmRouter> osrmRouter(new OsrmRouter(
&index, [&infoGetter](m2::PointD const & pt)
{
return infoGetter.GetRegionFile(pt);
return infoGetter.GetRegionCountryId(pt);
}
));
return osrmRouter;
@ -87,7 +87,7 @@ namespace integration
{
auto countryFileGetter = [&infoGetter](m2::PointD const & pt)
{
return infoGetter.GetRegionFile(pt);
return infoGetter.GetRegionCountryId(pt);
};
unique_ptr<IRouter> router = CreatePedestrianAStarBidirectionalRouter(index, countryFileGetter);
return shared_ptr<IRouter>(move(router));
@ -270,7 +270,7 @@ namespace integration
{
auto countryFileGetter = [&routerComponents](m2::PointD const & p) -> string
{
return routerComponents.GetCountryInfoGetter().GetRegionFile(p);
return routerComponents.GetCountryInfoGetter().GetRegionCountryId(p);
};
auto localFileGetter =
[&routerComponents](string const & countryFile) -> shared_ptr<LocalCountryFile>
@ -305,7 +305,7 @@ namespace integration
for (m2::PointD const & point : points)
{
string const mwmName = routerComponents.GetCountryInfoGetter().GetRegionFile(point);
string const mwmName = routerComponents.GetCountryInfoGetter().GetRegionCountryId(point);
TEST(find(expected.begin(), expected.end(), mwmName) != expected.end(),
("Can't find ", mwmName));
foundMwms.insert(mwmName);

3
routing/routing_tests/osrm_router_test.cpp
View file

@ -60,7 +60,8 @@ void TestMapping(InputDataT const & data,
platform::LocalCountryFile localFile(GetPlatform().WritableDir(), country, 0 /* version */);
localFile.SyncWithDisk();
platform::tests_support::ScopedMwm mapMwm(
localFile.GetCountryFile().GetNameWithExt(MapOptions::Map));
platform::GetFileName(localFile.GetCountryFile().GetName(), MapOptions::Map,
version::FOR_TESTING_TWO_COMPONENT_MWM1));
static char const ftSegsPath[] = "test1.tmp";
platform::CountryIndexes::PreparePlaceOnDisk(localFile);

20
routing/routing_tests/routing_mapping_test.cpp
View file

@ -29,7 +29,10 @@ public:
// MapOptions::Map is used as a parameter of CountryFile::GetNameWithExt() method.
LocalFileGenerator(string const & fileName)
: m_countryFile(fileName),
m_testDataFile(m_countryFile.GetNameWithExt(MapOptions::Map), "routing"),
m_testMapFile(platform::GetFileName(m_countryFile.GetName(), MapOptions::Map,
version::FOR_TESTING_TWO_COMPONENT_MWM1), "map"),
m_testRoutingFile(platform::GetFileName(m_countryFile.GetName(), MapOptions::CarRouting,
version::FOR_TESTING_TWO_COMPONENT_MWM1), "map"),
m_localFile(GetPlatform().WritableDir(), m_countryFile, 0 /* version */)
{
m_localFile.SyncWithDisk();
@ -43,23 +46,26 @@ public:
TestMwmSet & GetMwmSet() { return m_testSet; }
string const & GetCountryName() { return m_countryFile.GetNameWithoutExt(); }
string const & GetCountryName() { return m_countryFile.GetName(); }
size_t GetNumRefs() { return m_result.first.GetInfo()->GetNumRefs(); }
private:
void GenerateNecessarySections(LocalCountryFile const & localFile)
{
FilesContainerW dataCont(localFile.GetPath(MapOptions::CarRouting));
FilesContainerW routingCont(localFile.GetPath(MapOptions::CarRouting));
// Write version for routing file that is equal to correspondent mwm file.
FilesContainerW mwmCont(localFile.GetPath(MapOptions::Map));
FileWriter w1 = dataCont.GetWriter(VERSION_FILE_TAG);
FileWriter w1 = routingCont.GetWriter(VERSION_FILE_TAG);
FileWriter w2 = mwmCont.GetWriter(VERSION_FILE_TAG);
version::WriteVersion(w1, my::TodayAsYYMMDD());
FileWriter w2 = dataCont.GetWriter(ROUTING_MATRIX_FILE_TAG);
w2.Write("smth", 4);
version::WriteVersion(w2, my::TodayAsYYMMDD());
}
CountryFile m_countryFile;
ScopedFile m_testDataFile;
ScopedFile m_testMapFile;
ScopedFile m_testRoutingFile;
LocalCountryFile m_localFile;
TestMwmSet m_testSet;
pair<MwmSet::MwmId, MwmSet::RegResult> m_result;

2
search/search_query.cpp
View file

@ -1317,7 +1317,7 @@ void Query::SearchAddress(Results & res)
// Candidates for search around locality. Initially filled
// with mwms containing city center.
TMWMVector localityMwms;
string const localityFile = m_infoGetter.GetRegionFile(cityCenter);
string const localityFile = m_infoGetter.GetRegionCountryId(cityCenter);
auto localityMismatch = [&localityFile](shared_ptr<MwmInfo> const & info)
{
return info->GetCountryName() != localityFile;

2
search/search_tests_support/test_mwm_builder.cpp
View file

@ -67,7 +67,7 @@ void TestMwmBuilder::Finish()
feature::GenerateInfo info;
info.m_targetDir = m_file.GetDirectory();
info.m_tmpDir = m_file.GetDirectory();
CHECK(GenerateFinalFeatures(info, m_file.GetCountryFile().GetNameWithoutExt(), m_type),
CHECK(GenerateFinalFeatures(info, m_file.GetCountryFile().GetName(), m_type),
("Can't sort features."));
CHECK(my::DeleteFileX(tmpFilePath), ());

286
storage/country.cpp
View file

@ -1,31 +1,82 @@
#include "storage/country.hpp"
#include "platform/mwm_version.hpp"
#include "platform/platform.hpp"
#include "base/logging.hpp"
#include "3party/jansson/myjansson.hpp"
#include "std/utility.hpp"
using platform::CountryFile;
namespace storage
{
uint64_t Country::Size(MapOptions opt) const
{
uint64_t size = 0;
for (CountryFile const & file : m_files)
size += file.GetRemoteSize(opt);
return size;
}
void Country::AddFile(CountryFile const & file) { m_files.push_back(file); }
////////////////////////////////////////////////////////////////////////
// Mwm subtree attributes. They can be calculated based on information contained in countries.txt.
// The first in the pair is number of mwms in a subtree. The second is sum of sizes of
// all mwms in a subtree.
using TMwmSubtreeAttrs = pair<uint32_t, size_t>;
template <class ToDo>
void LoadGroupImpl(int depth, json_t * group, ToDo & toDo)
TMwmSubtreeAttrs LoadGroupSingleMwmsImpl(int depth, json_t * group, ToDo & toDo)
{
for (size_t i = 0; i < json_array_size(group); ++i)
uint32_t mwmCounter = 0;
size_t mwmSize = 0;
size_t const groupListSize = json_array_size(group);
for (size_t i = 0; i < groupListSize; ++i)
{
json_t * j = json_array_get(group, i);
char const * id = json_string_value(json_object_get(j, "id"));
if (!id)
MYTHROW(my::Json::Exception, ("LoadGroupImpl. Id is missing.", id));
size_t const nodeSize = static_cast<size_t>(json_integer_value(json_object_get(j, "s")));
// We expect that mwm and routing files should be less than 2GB.
Country * addedNode = toDo(id, nodeSize, depth);
json_t * oldIds = json_object_get(j, "old");
if (oldIds)
{
size_t const oldListSize = json_array_size(oldIds);
for (size_t k = 0; k < oldListSize; ++k)
{
string oldIdValue = json_string_value(json_array_get(oldIds, k));
toDo(oldIdValue, id);
}
}
uint32_t mwmChildCounter = 0;
size_t mwmChildSize = 0;
json_t * children = json_object_get(j, "g");
if (children)
{
TMwmSubtreeAttrs childAttr = LoadGroupSingleMwmsImpl(depth + 1, children, toDo);
mwmChildCounter = childAttr.first;
mwmChildSize = childAttr.second;
}
else
{
mwmChildCounter = 1; // It's a leaf. Any leaf contains one mwm.
mwmChildSize = nodeSize;
}
mwmCounter += mwmChildCounter;
mwmSize += mwmChildSize;
if (addedNode != nullptr)
addedNode->SetSubtreeAttrs(mwmChildCounter, mwmChildSize);
}
return make_pair(mwmCounter, mwmSize);
}
template <class ToDo>
void LoadGroupTwoComponentMwmsImpl(int depth, json_t * group, ToDo & toDo)
{
// @TODO(bykoianko) After we stop supporting two component mwms (with routing files)
// remove code below.
size_t const groupListSize = json_array_size(group);
for (size_t i = 0; i < groupListSize; ++i)
{
json_t * j = json_array_get(group, i);
@ -39,20 +90,18 @@ void LoadGroupImpl(int depth, json_t * group, ToDo & toDo)
if (!file)
file = name;
char const * flag = json_string_value(json_object_get(j, "c"));
toDo(name, file, flag ? flag : "",
// We expect what mwm and routing files should be less 2Gb
static_cast<uint32_t>(json_integer_value(json_object_get(j, "s"))),
// We expect that mwm and routing files should be less than 2GB.
toDo(file, static_cast<uint32_t>(json_integer_value(json_object_get(j, "s"))),
static_cast<uint32_t>(json_integer_value(json_object_get(j, "rs"))), depth);
json_t * children = json_object_get(j, "g");
if (children)
LoadGroupImpl(depth + 1, children, toDo);
LoadGroupTwoComponentMwmsImpl(depth + 1, children, toDo);
}
}
template <class ToDo>
bool LoadCountriesImpl(string const & jsonBuffer, ToDo & toDo)
bool LoadCountriesSingleMwmsImpl(string const & jsonBuffer, ToDo & toDo)
{
try
{
@ -60,7 +109,28 @@ bool LoadCountriesImpl(string const & jsonBuffer, ToDo & toDo)
json_t * children = json_object_get(root.get(), "g");
if (!children)
MYTHROW(my::Json::Exception, ("Root country doesn't have any groups"));
LoadGroupImpl(0, children, toDo);
TMwmSubtreeAttrs const treeAttrs = LoadGroupSingleMwmsImpl(0, children, toDo);
toDo.SetCountriesContainerAttrs(treeAttrs.first /* mwmNumber */,
treeAttrs.second /* mwmSizeBytes */);
return true;
}
catch (my::Json::Exception const & e)
{
LOG(LERROR, (e.Msg()));
return false;
}
}
template <class ToDo>
bool LoadCountriesTwoComponentMwmsImpl(string const & jsonBuffer, ToDo & toDo)
{
try
{
my::Json root(jsonBuffer.c_str());
json_t * children = json_object_get(root.get(), "g");
if (!children)
MYTHROW(my::Json::Exception, ("Root country doesn't have any groups"));
LoadGroupTwoComponentMwmsImpl(0, children, toDo);
return true;
}
catch (my::Json::Exception const & e)
@ -72,83 +142,106 @@ bool LoadCountriesImpl(string const & jsonBuffer, ToDo & toDo)
namespace
{
class DoStoreCountries
class DoStoreCountriesSingleMwms
{
CountriesContainerT & m_cont;
TCountriesContainer & m_cont;
TMapping m_idsMapping;
public:
DoStoreCountries(CountriesContainerT & cont) : m_cont(cont) {}
DoStoreCountriesSingleMwms(TCountriesContainer & cont) : m_cont(cont) {}
void operator()(string const & name, string const & file, string const & flag, uint32_t mapSize,
Country * operator()(string const & id, size_t mapSize, int depth)
{
Country country(id);
if (mapSize)
{
CountryFile countryFile(id);
countryFile.SetRemoteSizes(mapSize, 0 /* routingSize */);
country.SetFile(countryFile);
}
return &m_cont.AddAtDepth(depth, country);
}
void operator()(TCountryId const & oldId, TCountryId const & newId)
{
m_idsMapping[oldId].insert(newId);
}
void SetCountriesContainerAttrs(uint32_t mwmNumber, size_t mwmSizeBytes)
{
m_cont.Value().SetSubtreeAttrs(mwmNumber, mwmSizeBytes);
}
TMapping GetMapping() const { return m_idsMapping; }
};
class DoStoreCountriesTwoComponentMwms
{
TCountriesContainer & m_cont;
public:
DoStoreCountriesTwoComponentMwms(TCountriesContainer & cont) : m_cont(cont) {}
void operator()(string const & file, uint32_t mapSize,
uint32_t routingSize, int depth)
{
Country country(name, flag);
Country country(file);
if (mapSize)
{
CountryFile countryFile(file);
countryFile.SetRemoteSizes(mapSize, routingSize);
country.AddFile(countryFile);
country.SetFile(countryFile);
}
m_cont.AddAtDepth(depth, country);
}
};
class DoStoreFile2Info
class DoStoreFile2InfoSingleMwms
{
TMapping m_idsMapping;
map<string, CountryInfo> & m_file2info;
string m_lastFlag;
public:
DoStoreFile2Info(map<string, CountryInfo> & file2info) : m_file2info(file2info) {}
DoStoreFile2InfoSingleMwms(map<string, CountryInfo> & file2info)
: m_file2info(file2info) {}
void operator()(string name, string file, string const & flag, uint32_t mapSize, uint32_t, int)
Country * operator()(string const & id, uint32_t /* mapSize */, int /* depth */)
{
if (!flag.empty())
m_lastFlag = flag;
if (mapSize)
{
CountryInfo info;
// if 'file' is empty - it's equal to 'name'
if (!file.empty())
{
// make compound name: country_region
size_t const i = file.find_first_of('_');
if (i != string::npos)
name = file.substr(0, i) + '_' + name;
// fill 'name' only when it differs with 'file'
if (name != file)
info.m_name.swap(name);
}
else
file.swap(name);
// Do not use 'name' here! It was swapped!
info.m_flag = m_lastFlag;
m_file2info[file] = info;
}
CountryInfo info(id);
m_file2info[id] = move(info);
return nullptr;
}
void operator()(TCountryId const & oldId, TCountryId const & newId)
{
m_idsMapping[oldId].insert(newId);
}
void SetCountriesContainerAttrs(uint32_t, size_t) {}
TMapping GetMapping() const { return m_idsMapping; }
};
class DoStoreCode2File
class DoStoreFile2InfoTwoComponentMwms
{
multimap<string, string> & m_code2file;
TMapping m_idsMapping;
map<string, CountryInfo> & m_file2info;
public:
DoStoreCode2File(multimap<string, string> & code2file) : m_code2file(code2file) {}
DoStoreFile2InfoTwoComponentMwms(map<string, CountryInfo> & file2info)
: m_file2info(file2info) {}
void operator()(string const &, string const & file, string const & flag, uint32_t, uint32_t, int)
void operator()(string const & id, uint32_t mapSize, uint32_t /* routingSize */, int /* depth */)
{
m_code2file.insert(make_pair(flag, file));
if (mapSize == 0)
return;
CountryInfo info(id);
m_file2info[id] = info;
}
};
}
} // namespace
int64_t LoadCountries(string const & jsonBuffer, CountriesContainerT & countries)
int64_t LoadCountries(string const & jsonBuffer, TCountriesContainer & countries, TMapping * mapping /* = nullptr */)
{
countries.Clear();
@ -156,10 +249,33 @@ int64_t LoadCountries(string const & jsonBuffer, CountriesContainerT & countries
try
{
my::Json root(jsonBuffer.c_str());
version = json_integer_value(json_object_get(root.get(), "v"));
DoStoreCountries doStore(countries);
if (!LoadCountriesImpl(jsonBuffer, doStore))
return -1;
json_t * const rootPtr = root.get();
version = json_integer_value(json_object_get(rootPtr, "v"));
// Extracting root id.
bool const isSingleMwm = version::IsSingleMwm(version);
char const * const idKey = isSingleMwm ? "id" : "n";
char const * id = json_string_value(json_object_get(rootPtr, idKey));
if (!id)
MYTHROW(my::Json::Exception, ("LoadCountries. Id is missing.", id));
Country rootCountry(id);
// @TODO(bykoianko) Add CourtyFile to rootCountry with correct size.
countries.Value() = rootCountry;
if (isSingleMwm)
{
DoStoreCountriesSingleMwms doStore(countries);
if (!LoadCountriesSingleMwmsImpl(jsonBuffer, doStore))
return -1;
if (mapping)
*mapping = doStore.GetMapping();
}
else
{
DoStoreCountriesTwoComponentMwms doStore(countries);
if (!LoadCountriesTwoComponentMwmsImpl(jsonBuffer, doStore))
return -1;
}
}
catch (my::Json::Exception const & e)
{
@ -168,17 +284,31 @@ int64_t LoadCountries(string const & jsonBuffer, CountriesContainerT & countries
return version;
}
void LoadCountryFile2CountryInfo(string const & jsonBuffer, map<string, CountryInfo> & id2info)
void LoadCountryFile2CountryInfo(string const & jsonBuffer, map<string, CountryInfo> & id2info,
bool & isSingleMwm)
{
ASSERT(id2info.empty(), ());
DoStoreFile2Info doStore(id2info);
LoadCountriesImpl(jsonBuffer, doStore);
}
void LoadCountryCode2File(string const & jsonBuffer, multimap<string, string> & code2file)
{
ASSERT(code2file.empty(), ());
DoStoreCode2File doStore(code2file);
LoadCountriesImpl(jsonBuffer, doStore);
int64_t version = -1;
try
{
my::Json root(jsonBuffer.c_str());
version = json_integer_value(json_object_get(root.get(), "v"));
isSingleMwm = version::IsSingleMwm(version);
if (isSingleMwm)
{
DoStoreFile2InfoSingleMwms doStore(id2info);
LoadCountriesSingleMwmsImpl(jsonBuffer, doStore);
}
else
{
DoStoreFile2InfoTwoComponentMwms doStore(id2info);
LoadCountriesTwoComponentMwmsImpl(jsonBuffer, doStore);
}
}
catch (my::Json::Exception const & e)
{
LOG(LERROR, (e.Msg()));
}
}
} // namespace storage

57
storage/country.hpp
View file

@ -1,6 +1,7 @@
#pragma once
#include "storage/country_decl.hpp"
#include "storage/index.hpp"
#include "storage/simple_tree.hpp"
#include "storage/storage_defines.hpp"
@ -12,8 +13,6 @@
#include "geometry/rect2d.hpp"
#include "base/buffer_vector.hpp"
#include "std/string.hpp"
#include "std/vector.hpp"
@ -24,47 +23,49 @@ class SizeUpdater;
namespace storage
{
using TMapping = map<TCountryId, TCountriesSet>;
/// Serves as a proxy between GUI and downloaded files
class Country
{
friend class update::SizeUpdater;
/// Name in the country node tree
string m_name;
/// Flag to display
string m_flag;
/// stores squares with world pieces which are part of the country
buffer_vector<platform::CountryFile, 1> m_files;
TCountryId m_name;
/// |m_file| is a CountryFile of mwm with id == |m_name|.
/// if |m_name| is node id of a group of mwms, |m_file| is empty.
platform::CountryFile m_file;
/// The number of descendant mwm files of |m_name|. Only files (leaves in tree) are counted.
/// If |m_name| is a mwm file name |m_childrenNumber| == 1.
uint32_t m_subtreeMwmNumber;
/// Size of descendant mwm files of |m_name|.
/// If |m_name| is a mwm file name |m_subtreeMwmSizeBytes| is equal to size of the mwm.
size_t m_subtreeMwmSizeBytes;
public:
Country() {}
Country(string const & name, string const & flag = "") : m_name(name), m_flag(flag) {}
Country() = default;
Country(TCountryId const & name) : m_name(name) {}
bool operator<(Country const & other) const { return Name() < other.Name(); }
void AddFile(platform::CountryFile const & file);
size_t GetFilesCount() const { return m_files.size(); }
void SetFile(platform::CountryFile const & file) { m_file = file; }
void SetSubtreeAttrs(uint32_t subtreeMwmNumber, size_t subtreeMwmSizeBytes)
{
m_subtreeMwmNumber = subtreeMwmNumber;
m_subtreeMwmSizeBytes = subtreeMwmSizeBytes;
}
uint32_t GetSubtreeMwmCounter() const { return m_subtreeMwmNumber; }
size_t GetSubtreeMwmSizeBytes() const { return m_subtreeMwmSizeBytes; }
/// This function valid for current logic - one file for one country (region).
/// If the logic will be changed, replace GetFile with ForEachFile.
platform::CountryFile const & GetFile() const
{
ASSERT_EQUAL(m_files.size(), 1, (m_name));
return m_files.front();
}
string const & Name() const { return m_name; }
string const & Flag() const { return m_flag; }
uint64_t Size(MapOptions opt) const;
platform::CountryFile const & GetFile() const { return m_file; }
TCountryId const & Name() const { return m_name; }
};
typedef SimpleTree<Country> CountriesContainerT;
typedef SimpleTree<Country> TCountriesContainer;
/// @return version of country file or -1 if error was encountered
int64_t LoadCountries(string const & jsonBuffer, CountriesContainerT & countries);
int64_t LoadCountries(string const & jsonBuffer, TCountriesContainer & countries, TMapping * mapping = nullptr);
void LoadCountryFile2CountryInfo(string const & jsonBuffer, map<string, CountryInfo> & id2info);
void LoadCountryCode2File(string const & jsonBuffer, multimap<string, string> & code2file);
void LoadCountryFile2CountryInfo(string const & jsonBuffer, map<string, CountryInfo> & id2info,
bool & isSingleMwm);
} // namespace storage

15
storage/country_decl.hpp
View file

@ -1,16 +1,17 @@
#pragma once
#include "storage/index.hpp"
#include "geometry/rect2d.hpp"
#include "std/string.hpp"
namespace storage
{
struct CountryDef
{
/// File name without extension (equal to english name - used in search for region).
string m_name;
TCountryId m_name;
m2::RectD m_rect;
CountryDef() {}
@ -22,15 +23,17 @@ namespace storage
struct CountryInfo
{
CountryInfo() = default;
CountryInfo(string const & id) : m_name(id) {}
/// Name (in native language) of country or region.
/// (if empty - equals to file name of country - no additional memory)
string m_name;
/// Flag of country or region.
string m_flag;
bool IsNotEmpty() const { return !m_flag.empty(); }
bool IsNotEmpty() const { return !m_name.empty(); }
// @TODO(bykoianko) Twine will be used intead of this function.
// So id (fName) will be converted to a local name.
static void FileName2FullName(string & fName);
static void FullName2GroupAndMap(string const & fName, string & group, string & map);
};

29
storage/country_info_getter.cpp
View file

@ -4,12 +4,16 @@
#include "indexer/geometry_serialization.hpp"
#include "geometry/latlon.hpp"
#include "geometry/mercator.hpp"
#include "geometry/region2d.hpp"
#include "coding/read_write_utils.hpp"
#include "base/string_utils.hpp"
#include "3party/Alohalytics/src/alohalytics.h"
#include "std/bind.hpp"
#include "std/function.hpp"
#include "std/limits.hpp"
@ -46,10 +50,21 @@ private:
} // namespace
// CountryInfoGetter -------------------------------------------------------------------------------
string CountryInfoGetter::GetRegionFile(m2::PointD const & pt) const
TCountryId CountryInfoGetter::GetRegionCountryId(m2::PointD const & pt) const
{
IdType const id = FindFirstCountry(pt);
return id != kInvalidId ? m_countries[id].m_name : string();
return id != kInvalidId ? m_countries[id].m_name : TCountryId();
}
void CountryInfoGetter::GetRegionsCountryId(m2::PointD const & pt, TCountriesVec & closestCoutryIds)
{
// @TODO(bykoianko) Now this method fills |closestCoutryIds| with only a country id of mwm
// which covers |pt|. This method should fill |closestCoutryIds| with several mwms
// which cover |pt| and close to |pt|.
closestCoutryIds.clear();
TCountryId countryId = GetRegionCountryId(pt);
if (!countryId.empty())
closestCoutryIds.emplace_back(countryId);
}
void CountryInfoGetter::GetRegionInfo(m2::PointD const & pt, CountryInfo & info) const
@ -127,6 +142,11 @@ CountryInfoGetter::IdType CountryInfoGetter::FindFirstCountry(m2::PointD const &
if (m_countries[id].m_rect.IsPointInside(pt) && IsBelongToRegionImpl(id, pt))
return id;
}
ms::LatLon const latLon = MercatorBounds::ToLatLon(pt);
alohalytics::LogEvent(m_isSingleMwm ? "Small mwm case. CountryInfoGetter could not find any mwm by point."
: "Big mwm case. CountryInfoGetter could not find any mwm by point.",
alohalytics::Location::FromLatLon(latLon.lat, latLon.lon));
return kInvalidId;
}
@ -142,14 +162,14 @@ void CountryInfoGetter::ForEachCountry(string const & prefix, ToDo && toDo) cons
// CountryInfoReader -------------------------------------------------------------------------------
CountryInfoReader::CountryInfoReader(ModelReaderPtr polyR, ModelReaderPtr countryR)
: m_reader(polyR), m_cache(3)
: CountryInfoGetter(true), m_reader(polyR), m_cache(3)
{
ReaderSource<ModelReaderPtr> src(m_reader.GetReader(PACKED_POLYGONS_INFO_TAG));
rw::Read(src, m_countries);
string buffer;
countryR.ReadAsString(buffer);
LoadCountryFile2CountryInfo(buffer, m_id2info);
LoadCountryFile2CountryInfo(buffer, m_id2info, m_isSingleMwm);
}
void CountryInfoReader::ClearCachesImpl() const
@ -192,6 +212,7 @@ bool CountryInfoReader::IsBelongToRegionImpl(size_t id, m2::PointD const & pt) c
// CountryInfoGetterForTesting ---------------------------------------------------------------------
CountryInfoGetterForTesting::CountryInfoGetterForTesting(vector<CountryDef> const & countries)
: CountryInfoGetter(true)
{
for (auto const & country : countries)
AddCountry(country);

14
storage/country_info_getter.hpp
View file

@ -23,12 +23,19 @@ public:
using IdType = size_t;
using IdSet = vector<IdType>;
CountryInfoGetter(bool isSingleMwm) : m_isSingleMwm(isSingleMwm) {}
virtual ~CountryInfoGetter() = default;
// Returns country file name without an extension for a country |pt|
// belongs to. If there are no such country, returns an empty
// string.
string GetRegionFile(m2::PointD const & pt) const;
TCountryId GetRegionCountryId(m2::PointD const & pt) const;
// Returns a list of country ids by a |pt| in mercator.
// |closestCoutryIds| is filled with country ids of mwm which covers |pt| or close to it.
// |closestCoutryIds| is not filled with country world.mwm country id and with custom mwm.
// If |pt| is covered by a sea or a ocean closestCoutryIds may be left empty.
void GetRegionsCountryId(m2::PointD const & pt, TCountriesVec & closestCoutryIds);
// Returns info for a region |pt| belongs to.
void GetRegionInfo(m2::PointD const & pt, CountryInfo & info) const;
@ -81,6 +88,11 @@ protected:
// Maps country file name without an extension to a country info.
map<string, CountryInfo> m_id2info;
// m_isSingleMwm == true if the system is currently working with single (small) mwms
// and false otherwise.
// @TODO(bykoianko) Init m_isSingleMwm correctly.
bool m_isSingleMwm;
};
// This class reads info about countries from polygons file and

23
storage/index.cpp
View file

@ -2,23 +2,12 @@
#include "std/sstream.hpp"
namespace storage
{
// GCC bug? Can't move initialization to hpp file (linker error).
const int TIndex::INVALID = -1;
storage::TCountryId const kInvalidCountryId;
string DebugPrint(TIndex const & r)
{
ostringstream out;
out << "storage::TIndex(" << r.m_group << ", " << r.m_country << ", " << r.m_region << ")";
return out.str();
}
storage::TCountryId const kInvalidCountryId;
bool IsCountryIdValid(TCountryId const & countryId)
{
return countryId != kInvalidCountryId;
}
} // namespace storage
bool IsCountryIdValid(TCountryId const & countryId)
{
return countryId != kInvalidCountryId;
}
} // namespace storage

50
storage/index.hpp
View file

@ -1,53 +1,17 @@
#pragma once
#include "std/set.hpp"
#include "std/string.hpp"
#include "std/vector.hpp"
namespace storage
{
using TCountryId = string;
using TCountriesSet = set<TCountryId>;
using TCountriesVec = vector<TCountryId>;
using TCountryId = string;
using TCountriesSet = set<TCountryId>;
using TCountriesVec = vector<TCountryId>;
extern const storage::TCountryId kInvalidCountryId;
extern const storage::TCountryId kInvalidCountryId;
// @TODO(bykoianko) Check in country tree if the countryId valid.
bool IsCountryIdValid(TCountryId const & countryId);
struct TIndex
{
static int const INVALID;
int m_group;
int m_country;
int m_region;
TIndex(int group = INVALID, int country = INVALID, int region = INVALID)
: m_group(group), m_country(country), m_region(region) {}
bool IsValid() const { return (m_group != INVALID); }
bool operator==(TIndex const & other) const
{
return (m_group == other.m_group &&
m_country == other.m_country &&
m_region == other.m_region);
}
bool operator!=(TIndex const & other) const
{
return !(*this == other);
}
bool operator<(TIndex const & other) const
{
if (m_group != other.m_group)
return m_group < other.m_group;
else if (m_country != other.m_country)
return m_country < other.m_country;
return m_region < other.m_region;
}
};
string DebugPrint(TIndex const & r);
// @TODO(bykoianko) Check in counrtry tree if the countryId valid.
bool IsCountryIdValid(TCountryId const & countryId);
} // namespace storage

7
storage/queued_country.cpp
View file

@ -4,10 +4,11 @@
namespace storage
{
QueuedCountry::QueuedCountry(TIndex const & index, MapOptions opt)
: m_index(index), m_init(opt), m_left(opt), m_current(MapOptions::Nothing)
QueuedCountry::QueuedCountry(TCountryId const & countryId, MapOptions opt)
: m_countryId(countryId), m_init(opt), m_left(opt), m_current(MapOptions::Nothing)
{
ASSERT(GetIndex().IsValid(), ("Only valid countries may be downloaded."));
// @TODO(bykoianko) Probably it's nessecary to check if InIndexInCountryTree here.
ASSERT(IsCountryIdValid(GetCountryId()), ("Only valid countries may be downloaded."));
ASSERT(m_left != MapOptions::Nothing, ("Empty file set was requested for downloading."));
SwitchToNextFile();
}

11
storage/queued_country.hpp
View file

@ -6,24 +6,27 @@
namespace storage
{
/// Country queued for downloading.
/// @TODO(bykoianko) This class assumes that a map may consist of one or two mwm files.
/// But single mwm files are used now. So this class should be redisigned to support
/// only single mwm case.
class QueuedCountry
{
public:
QueuedCountry(TIndex const & index, MapOptions opt);
QueuedCountry(TCountryId const & m_countryId, MapOptions opt);
void AddOptions(MapOptions opt);
void RemoveOptions(MapOptions opt);
bool SwitchToNextFile();
inline TIndex const & GetIndex() const { return m_index; }
inline TCountryId const & GetCountryId() const { return m_countryId; }
inline MapOptions GetInitOptions() const { return m_init; }
inline MapOptions GetCurrentFile() const { return m_current; }
inline MapOptions GetDownloadedFiles() const { return UnsetOptions(m_init, m_left); }
inline bool operator==(TIndex const & index) const { return m_index == index; }
inline bool operator==(TCountryId const & countryId) const { return m_countryId == countryId; }
private:
TIndex m_index;
TCountryId m_countryId;
MapOptions m_init;
MapOptions m_left;
MapOptions m_current;

770
storage/storage.cpp
View file

File diff suppressed because it is too large Load diff

210
storage/storage.hpp
View file

@ -10,7 +10,6 @@
#include "std/function.hpp"
#include "std/list.hpp"
#include "std/set.hpp"
#include "std/shared_ptr.hpp"
#include "std/string.hpp"
#include "std/unique_ptr.hpp"
@ -28,7 +27,7 @@ struct NodeAttrs
/// belongs to the node. If the node isn't expandable |m_mapsDownloaded| == 1.
uint32_t m_mwmCounter;
/// Number of mwms belonging to the node which has been downloaded.
/// Number of mwms belonging to the node which has been donwloaded.
uint32_t m_localMwmCounter;
/// If it's not an expandable node, |m_nodeSize| is size of one mwm according to countries.txt.
@ -66,12 +65,14 @@ struct NodeAttrs
TStatus m_status;
};
/// Can be used to store local maps and/or maps available for download
/// This class is used for downloading, updating and deleting maps.
class Storage
{
public:
struct StatusCallback;
using TUpdate = function<void(platform::LocalCountryFile const &)>;
using TChangeCountryFunction = function<void(TCountryId const &)>;
using TProgressFunction = function<void(TCountryId const &, LocalAndRemoteSizeT const &)>;
private:
/// We support only one simultaneous request at the moment
@ -80,9 +81,9 @@ private:
/// stores timestamp for update checks
int64_t m_currentVersion;
CountriesContainerT m_countries;
TCountriesContainer m_countries;
typedef list<QueuedCountry> TQueue;
using TQueue = list<QueuedCountry>;
/// @todo. It appeared that our application uses m_queue from
/// different threads without any synchronization. To reproduce it
@ -93,11 +94,10 @@ private:
TQueue m_queue;
/// stores countries whose download has failed recently
typedef set<TIndex> TCountriesSet;
TCountriesSet m_failedCountries;
using TLocalFilePtr = shared_ptr<platform::LocalCountryFile>;
map<TIndex, list<TLocalFilePtr>> m_localFiles;
map<TCountryId, list<TLocalFilePtr>> m_localFiles;
// Our World.mwm and WorldCoasts.mwm are fake countries, together with any custom mwm in data
// folder.
@ -109,11 +109,11 @@ private:
/// @name Communicate with GUI
//@{
typedef function<void(TIndex const &)> TChangeCountryFunction;
typedef function<void(TIndex const &, LocalAndRemoteSizeT const &)> TProgressFunction;
int m_currentSlotId;
list<StatusCallback> m_statusCallbacks;
struct CountryObservers
{
TChangeCountryFunction m_changeCountryFn;
@ -129,11 +129,25 @@ private:
// country were successfully downloaded.
TUpdate m_update;
// If |m_dataDir| is not empty Storage will create version directories and download maps in
// platform::WritableDir/|m_dataDir|/. Not empty |m_dataDir| can be used only for
// downloading maps to a special place but not for continue working with them from this place.
string m_dataDir;
// A list of urls for downloading maps. It's necessary for storage integration tests.
// For example {"http://new-search.mapswithme.com/"}.
vector<string> m_downloadingUrlsForTesting;
// |m_downloadMapOnTheMap| is called when an end user clicks on download map or retry button
// on the map.
TDownloadFn m_downloadMapOnTheMap;
void DownloadNextCountryFromQueue();
void LoadCountriesFile(bool forceReload);
void LoadCountriesFile(string const & pathToCountriesFile,
string const & dataDir, TMapping * mapping = nullptr);
void ReportProgress(TIndex const & index, pair<int64_t, int64_t> const & p);
void ReportProgress(TCountryId const & countryId, pair<int64_t, int64_t> const & p);
/// Called on the main thread by MapFilesDownloader when list of
/// suitable servers is received.
@ -147,16 +161,36 @@ private:
/// during the downloading process.
void OnMapFileDownloadProgress(MapFilesDownloader::TProgress const & progress);
bool RegisterDownloadedFiles(TIndex const & index, MapOptions files);
void OnMapDownloadFinished(TIndex const & index, bool success, MapOptions files);
bool RegisterDownloadedFiles(TCountryId const & countryId, MapOptions files);
void OnMapDownloadFinished(TCountryId const & countryId, bool success, MapOptions files);
/// Initiates downloading of the next file from the queue.
void DownloadNextFile(QueuedCountry const & country);
public:
Storage();
/// \brief Storage will create its directories in Writable Directory
/// (gotten with platform::WritableDir) by default.
/// \param pathToCountriesFile is a name of countries.txt file.
/// \param dataDir If |dataDir| is not empty Storage will create its directory in WritableDir/|dataDir|.
/// \note if |dataDir| is not empty the instance of Storage can be used only for downloading map files
/// but not for continue working with them.
/// If |dataDir| is not empty the work flow is
/// * create a instance of Storage with a special countries.txt and |dataDir|
/// * download some maps to WritableDir/|dataDir|
/// * destroy the instance of Storage and move the downloaded maps to proper place
Storage(string const & pathToCountriesFile = COUNTRIES_FILE, string const & dataDir = string());
/// \brief This constructor should be used for testing only.
Storage(string const & referenceCountriesTxtJsonForTesting,
unique_ptr<MapFilesDownloader> mapDownloaderForTesting);
void Init(TUpdate const & update);
/// @name Interface with clients (Android/iOS).
/// \brief It represents the interface which can be used by clients (Android/iOS).
/// The term node means an mwm or a group of mwm like a big country.
/// The term node id means a string id of mwm or a group of mwm. The sting contains
/// a name of file with mwm of a name country(territory).
//@{
using TOnSearchResultCallback = function<void (TCountryId const &)>;
using TOnStatusChangedCallback = function<void (TCountryId const &)>;
/// \brief Information for "Update all mwms" button.
struct UpdateInfo
@ -165,13 +199,20 @@ public:
size_t m_totalUpdateSizeInBytes;
};
/// Switch on new storage version, remove old mwm
/// and add required mwm's into download queue.
void Migrate();
bool HaveDownloadedCountries();
void DeleteAllLocalMaps(vector<TIndex> * existedCountries = nullptr);
struct StatusCallback
{
/// \brief m_onStatusChanged is called by MapRepository when status of
/// a node is changed. If this method is called for an mwm it'll be called for
/// every its parent and grandparents.
/// \param CountryId is id of mwm or an mwm group which status has been changed.
TOnStatusChangedCallback m_onStatusChanged;
};
unique_ptr<Storage> m_prefetchStorage;
void PrefetchMigrateData();
void SaveDownloadQueue();
void RestoreDownloadQueue();
// New downloader interface.
/// \brief Returns root country id of the county tree.
TCountryId const GetRootId() const;
/// \param childrenId is filled with children node ids by a parent. For example GetChildren(GetRootId())
@ -193,6 +234,8 @@ public:
/// countries. That means all mwm of the countries have been downloaded.
void GetCountyListToDownload(TCountriesVec & countryList) const;
/// \brief Returns current version for mwms which are available on the server.
inline int64_t GetCurrentDataVersion() const { return m_currentVersion; }
/// \brief Returns true if the node with countryId has been downloaded and false othewise.
/// If countryId is a expandable returns true if all mwms which belongs to it have downloaded.
/// Returns false if countryId is an unknown string.
@ -231,6 +274,41 @@ public:
/// \brief Get information for mwm update button.
/// \return true if updateInfo is filled correctly and false otherwise.
bool GetUpdateInfo(TCountryId const & countryId, UpdateInfo & updateInfo) const { return true; }
/// \brief Update all mwm in case of changing mwm hierarchy of mwm borders.
/// This method:
/// * removes all mwms
/// * downloads mwms with the same coverage
/// \note This method is used in very rare case.
/// \return false in case of error and true otherwise.
bool UpdateAllAndChangeHierarchy();
/// \brief Subscribe on change status callback.
/// \returns a unique index of added status callback structure.
size_t SubscribeStatusCallback(StatusCallback const & statusCallbacks);
/// \brief Unsubscribe from change status callback.
/// \param index is a unique index of callback retruned by SubscribeStatusCallback.
void UnsubscribeStatusCallback(size_t index);
/// \brief Sets callback which will be called in case of a click on download map button on the map.
void SetCallbackForClickOnDownloadMap(TDownloadFn & downloadFn) { m_downloadMapOnTheMap = downloadFn; }
/// \brief Calls |m_downloadMapOnTheMap| if one has been set.
/// \param |countryId| is country id of a leaf. That means it's a file name.
/// \note This method should be called for a click of download map button
/// and for a click for retry downloading map button on the map.
void DoClickOnDownloadMap(TCountryId const & countryId);
//@}
/// \returns real (not fake) local maps contained in countries.txt.
/// So this method does not return custom user local maps and World and WorldCoosts country id.
void GetLocalRealMaps(TCountriesVec & localMaps) const;
void Init(TUpdate const & update);
/// Delete local maps and aggregate their Id if needed
void DeleteAllLocalMaps(TCountriesVec * existedCountries = nullptr);
/// Switch on new storage version, remove old mwm
/// and add required mwm's into download queue.
void Migrate(TCountriesVec const & existedCountries);
// Clears local files registry and downloader's queue.
void Clear();
@ -250,96 +328,90 @@ public:
int Subscribe(TChangeCountryFunction const & change, TProgressFunction const & progress);
void Unsubscribe(int slotId);
Country const & CountryByIndex(TIndex const & index) const;
TIndex FindIndexByFile(string const & name) const;
Country const & CountryLeafByCountryId(TCountryId const & countryId) const;
Country const & CountryByCountryId(TCountryId const & countryId) const;
TCountryId FindCountryIdByFile(string const & name) const;
/// @todo Temporary function to gel all associated indexes for the country file name.
/// Will be removed in future after refactoring.
vector<TIndex> FindAllIndexesByFile(string const & name) const;
void GetGroupAndCountry(TIndex const & index, string & group, string & country) const;
TCountriesVec FindAllIndexesByFile(string const & name) const;
void GetGroupAndCountry(TCountryId const & countryId, string & group, string & country) const;
size_t CountriesCount(TIndex const & index) const;
string const & CountryName(TIndex const & index) const;
string const & CountryFlag(TIndex const & index) const;
size_t CountriesCount(TCountryId const & countryId) const;
string const & CountryName(TCountryId const & countryId) const;
bool IsCoutryIdInCountryTree(TCountryId const & countryId) const;
LocalAndRemoteSizeT CountrySizeInBytes(TIndex const & index, MapOptions opt) const;
platform::CountryFile const & GetCountryFile(TIndex const & index) const;
LocalAndRemoteSizeT CountrySizeInBytes(TCountryId const & countryId, MapOptions opt) const;
platform::CountryFile const & GetCountryFile(TCountryId const & countryId) const;
TLocalFilePtr GetLatestLocalFile(platform::CountryFile const & countryFile) const;
TLocalFilePtr GetLatestLocalFile(TIndex const & index) const;
TLocalFilePtr GetLatestLocalFile(TCountryId const & countryId) const;
/// Fast version, doesn't check if country is out of date
TStatus CountryStatus(TIndex const & index) const;
/// Slow version, but checks if country is out of date
TStatus CountryStatusEx(TIndex const & index) const;
void CountryStatusEx(TIndex const & index, TStatus & status, MapOptions & options) const;
TStatus CountryStatusEx(TCountryId const & countryId) const;
/// Puts country denoted by index into the downloader's queue.
/// Puts country denoted by countryId into the downloader's queue.
/// During downloading process notifies observers about downloading
/// progress and status changes.
void DownloadCountry(TIndex const & index, MapOptions opt);
void DownloadCountry(TCountryId const & countryId, MapOptions opt);
/// Removes country files (for all versions) from the device.
/// Notifies observers about country status change.
void DeleteCountry(TIndex const & index, MapOptions opt);
void DeleteCountry(TCountryId const & countryId, MapOptions opt);
/// Removes country files of a particular version from the device.
/// Notifies observers about country status change.
void DeleteCustomCountryVersion(platform::LocalCountryFile const & localFile);
/// \return True iff country denoted by index was successfully
/// \return True iff country denoted by countryId was successfully
/// deleted from the downloader's queue.
bool DeleteFromDownloader(TIndex const & index);
bool DeleteFromDownloader(TCountryId const & countryId);
bool IsDownloadInProgress() const;
TIndex GetCurrentDownloadingCountryIndex() const;
TCountryId GetCurrentDownloadingCountryId() const;
void NotifyStatusChanged(TIndex const & index);
void NotifyStatusChanged(TCountryId const & countryId);
/// get download url by index & options(first search file name by index, then format url)
string GetFileDownloadUrl(string const & baseUrl, TIndex const & index, MapOptions file) const;
/// get download url by countryId & options(first search file name by countryId, then format url)
string GetFileDownloadUrl(string const & baseUrl, TCountryId const & countryId, MapOptions file) const;
/// get download url by base url & file name
string GetFileDownloadUrl(string const & baseUrl, string const & fName) const;
/// @param[out] res Populated with oudated countries.
void GetOutdatedCountries(vector<Country const *> & countries) const;
inline int64_t GetCurrentDataVersion() const { return m_currentVersion; }
void SetDownloaderForTesting(unique_ptr<MapFilesDownloader> && downloader);
void SetCurrentDataVersionForTesting(int64_t currentVersion);
bool IsLeaf(TIndex const & index) const { return CountriesCount(index) == 0; }
void SetDownloadingUrlsForTesting(vector<string> const & downloadingUrls)
{
m_downloadingUrlsForTesting = downloadingUrls;
}
private:
friend void UnitTest_StorageTest_DeleteCountry();
TStatus CountryStatusWithoutFailed(TIndex const & index) const;
TStatus CountryStatusFull(TIndex const & index, TStatus const status) const;
// Modifies file set of requested files - always adds a map file
// when routing file is requested for downloading, but drops all
// already downloaded and up-to-date files.
MapOptions NormalizeDownloadFileSet(TIndex const & index, MapOptions options) const;
TStatus CountryStatusWithoutFailed(TCountryId const & countryId) const;
TStatus CountryStatusFull(TCountryId const & countryId, TStatus const status) const;
// Modifies file set of file to deletion - always adds (marks for
// removal) a routing file when map file is marked for deletion.
MapOptions NormalizeDeleteFileSet(MapOptions options) const;
// Returns a pointer to a country in the downloader's queue.
QueuedCountry * FindCountryInQueue(TIndex const & index);
QueuedCountry * FindCountryInQueue(TCountryId const & countryId);
// Returns a pointer to a country in the downloader's queue.
QueuedCountry const * FindCountryInQueue(TIndex const & index) const;
QueuedCountry const * FindCountryInQueue(TCountryId const & countryId) const;
// Returns true when country is in the downloader's queue.
bool IsCountryInQueue(TIndex const & index) const;
bool IsCountryInQueue(TCountryId const & countryId) const;
// Returns true when country is first in the downloader's queue.
bool IsCountryFirstInQueue(TIndex const & index) const;
bool IsCountryFirstInQueue(TCountryId const & countryId) const;
// Returns local country files of a particular version, or wrapped
// nullptr if there're no country files corresponding to the
// version.
TLocalFilePtr GetLocalFile(TIndex const & index, int64_t version) const;
TLocalFilePtr GetLocalFile(TCountryId const & countryId, int64_t version) const;
// Tries to register disk files for a real (listed in countries.txt)
// country. If map files of the same version were already
@ -347,18 +419,18 @@ private:
void RegisterCountryFiles(TLocalFilePtr localFile);
// Registers disk files for a country. This method must be used only
// for real (listed in counties.txt) countries.
void RegisterCountryFiles(TIndex const & index, string const & directory, int64_t version);
// for real (listed in countries.txt) countries.
void RegisterCountryFiles(TCountryId const & countryId, string const & directory, int64_t version);
// Registers disk files for a country. This method must be used only
// for custom (made by user) map files.
void RegisterFakeCountryFiles(platform::LocalCountryFile const & localFile);
// Removes disk files for all versions of a country.
void DeleteCountryFiles(TIndex const & index, MapOptions opt);
void DeleteCountryFiles(TCountryId const & countryId, MapOptions opt);
// Removes country files from downloader.
bool DeleteCountryFilesFromDownloader(TIndex const & index, MapOptions opt);
bool DeleteCountryFilesFromDownloader(TCountryId const & countryId, MapOptions opt);
// Returns download size of the currently downloading file for the
// queued country.
@ -366,6 +438,14 @@ private:
// Returns a path to a place on disk downloader can use for
// downloaded files.
string GetFileDownloadPath(TIndex const & index, MapOptions file) const;
string GetFileDownloadPath(TCountryId const & countryId, MapOptions file) const;
void CountryStatusEx(TCountryId const & countryId, TStatus & status, MapOptions & options) const;
/// Fast version, doesn't check if country is out of date
TStatus CountryStatus(TCountryId const & countryId) const;
/// Returns status for a node (group node or not)
TStatus NodeStatus(TCountriesContainer const & node) const;
};
bool HasCountryId(TCountriesVec const & sorted, TCountryId const & countyId);
} // storage

2
storage/storage.pro
View file

@ -22,6 +22,7 @@ HEADERS += \
simple_tree.hpp \
storage.hpp \
storage_defines.hpp \
storage_helpers.hpp \
SOURCES += \
country.cpp \
@ -32,3 +33,4 @@ SOURCES += \
queued_country.cpp \
storage.cpp \
storage_defines.cpp \
storage_helpers.cpp \

7
storage/storage_defines.hpp
View file

@ -1,6 +1,9 @@
#pragma once
#include "storage/index.hpp"
#include "std/cstdint.hpp"
#include "std/function.hpp"
#include "std/string.hpp"
#include "std/utility.hpp"
@ -24,4 +27,6 @@ namespace storage
string DebugPrint(TStatus status);
typedef pair<uint64_t, uint64_t> LocalAndRemoteSizeT;
} // namespace storage
} // namespace storage
using TDownloadFn = function<void (storage::TCountryId const &)>;

6
storage/storage_tests/country_info_getter_test.cpp
View file

@ -40,15 +40,12 @@ UNIT_TEST(CountryInfoGetter_GetByPoint_Smoke)
// Minsk
getter->GetRegionInfo(MercatorBounds::FromLatLon(53.9022651, 27.5618818), info);
TEST_EQUAL(info.m_name, "Belarus", ());
TEST_EQUAL(info.m_flag, "by", ());
getter->GetRegionInfo(MercatorBounds::FromLatLon(-6.4146288, -38.0098101), info);
TEST_EQUAL(info.m_name, "Brazil, Northeast", ());
TEST_EQUAL(info.m_flag, "br", ());
getter->GetRegionInfo(MercatorBounds::FromLatLon(34.6509, 135.5018), info);
TEST_EQUAL(info.m_name, "Japan, Kinki", ());
TEST_EQUAL(info.m_flag, "jp", ());
}
UNIT_TEST(CountryInfoGetter_ValidName_Smoke)
@ -57,7 +54,8 @@ UNIT_TEST(CountryInfoGetter_ValidName_Smoke)
ReaderPtr<Reader>(GetPlatform().GetReader(COUNTRIES_FILE)).ReadAsString(buffer);
map<string, CountryInfo> id2info;
storage::LoadCountryFile2CountryInfo(buffer, id2info);
bool isSingleMwm;
storage::LoadCountryFile2CountryInfo(buffer, id2info, isSingleMwm);
TEST(!IsEmptyName(id2info, "Germany_Baden-Wurttemberg"), ());
TEST(!IsEmptyName(id2info, "France_Paris & Ile-de-France"), ());

28
storage/storage_tests/queued_country_tests.cpp
View file

@ -8,10 +8,10 @@ namespace storage
UNIT_TEST(QueuedCountry_AddOptions)
{
Storage storage;
TIndex const index = storage.FindIndexByFile("Angola");
QueuedCountry country(index, MapOptions::CarRouting);
TCountryId const countryId = storage.FindCountryIdByFile("USA_Georgia");
QueuedCountry country(countryId, MapOptions::CarRouting);
TEST_EQUAL(index, country.GetIndex(), ());
TEST_EQUAL(countryId, country.GetCountryId(), ());
TEST_EQUAL(MapOptions::CarRouting, country.GetInitOptions(), ());
TEST_EQUAL(MapOptions::CarRouting, country.GetCurrentFile(), ());
@ -31,10 +31,10 @@ UNIT_TEST(QueuedCountry_AddOptions)
UNIT_TEST(QueuedCountry_RemoveOptions)
{
Storage storage;
TIndex const index = storage.FindIndexByFile("Angola");
TCountryId const countryId = storage.FindCountryIdByFile("USA_Georgia");
{
QueuedCountry country(index, MapOptions::MapWithCarRouting);
QueuedCountry country(countryId, MapOptions::MapWithCarRouting);
TEST_EQUAL(MapOptions::MapWithCarRouting, country.GetInitOptions(), ());
TEST_EQUAL(MapOptions::Map, country.GetCurrentFile(), ());
TEST_EQUAL(MapOptions::Nothing, country.GetDownloadedFiles(), ());
@ -51,7 +51,7 @@ UNIT_TEST(QueuedCountry_RemoveOptions)
}
{
QueuedCountry country(index, MapOptions::MapWithCarRouting);
QueuedCountry country(countryId, MapOptions::MapWithCarRouting);
TEST_EQUAL(MapOptions::MapWithCarRouting, country.GetInitOptions(), ());
TEST_EQUAL(MapOptions::Map, country.GetCurrentFile(), ());
TEST_EQUAL(MapOptions::Nothing, country.GetDownloadedFiles(), ());
@ -68,7 +68,7 @@ UNIT_TEST(QueuedCountry_RemoveOptions)
}
{
QueuedCountry country(index, MapOptions::MapWithCarRouting);
QueuedCountry country(countryId, MapOptions::MapWithCarRouting);
TEST_EQUAL(MapOptions::MapWithCarRouting, country.GetInitOptions(), ());
TEST_EQUAL(MapOptions::Map, country.GetCurrentFile(), ());
TEST_EQUAL(MapOptions::Nothing, country.GetDownloadedFiles(), ());
@ -89,18 +89,4 @@ UNIT_TEST(QueuedCountry_RemoveOptions)
TEST_EQUAL(MapOptions::CarRouting, country.GetDownloadedFiles(), ());
}
}
UNIT_TEST(QueuedCountry_Bits)
{
Storage storage;
TIndex const index = storage.FindIndexByFile("Angola");
QueuedCountry country(index, MapOptions::MapWithCarRouting);
TEST_EQUAL(MapOptions::Nothing, country.GetDownloadedFiles(), ());
TEST(country.SwitchToNextFile(), ());
TEST_EQUAL(MapOptions::Map, country.GetDownloadedFiles(), ());
TEST(!country.SwitchToNextFile(), ());
TEST_EQUAL(MapOptions::MapWithCarRouting, country.GetDownloadedFiles(), ());
}
} // namespace storage

834
storage/storage_tests/storage_tests.cpp
View file

File diff suppressed because it is too large Load diff