From 150eaa1c6bbe0096436f97c65e5b7df59b0bfd07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?F=C3=A1bio=20Gomes?= Date: Thu, 23 May 2024 12:15:39 +0100 Subject: [PATCH 1/8] [WIP] Add User Route saving functionality Enables the creation of user routes to be loaded at any time. Overloads previous methods that handled the saved route points and creates a generalised verion capable of using any file path. New function use these generalised methods to handle user routes. Adds a test to the map_tests folder (in progress) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Fábio Gomes --- map/map_tests/CMakeLists.txt | 1 + map/map_tests/user_routes_test.cpp | 42 ++++++++++ map/routing_manager.cpp | 124 +++++++++++++++++++++++------ map/routing_manager.hpp | 28 ++++++- 4 files changed, 168 insertions(+), 27 deletions(-) create mode 100644 map/map_tests/user_routes_test.cpp diff --git a/map/map_tests/CMakeLists.txt b/map/map_tests/CMakeLists.txt index 0ca98f3c7b..7f6d7c9e5f 100644 --- a/map/map_tests/CMakeLists.txt +++ b/map/map_tests/CMakeLists.txt @@ -16,6 +16,7 @@ set(SRC power_manager_tests.cpp search_api_tests.cpp transliteration_test.cpp + user_routes_test.cpp working_time_tests.cpp ) diff --git a/map/map_tests/user_routes_test.cpp b/map/map_tests/user_routes_test.cpp new file mode 100644 index 0000000000..639e5de87d --- /dev/null +++ b/map/map_tests/user_routes_test.cpp @@ -0,0 +1,42 @@ +#include "testing/testing.hpp" + +#include "map/routing_manager.hpp" + +#include +#include + +namespace user_routes_test +{ +using namespace std; + +#define RM_CALLBACKS { \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr) \ + } + +class TestDelegate : public RoutingManager::Delegate +{ + void OnRouteFollow(routing::RouterType type) override + { + // Empty + } + + void RegisterCountryFilesOnRoute(std::shared_ptr ptr) const override + { + // Empty + } +}; + +UNIT_TEST(user_routes_test) +{ + TestDelegate d = TestDelegate(); + TestDelegate & dRef = d; + RoutingManager rManager(RM_CALLBACKS, dRef); + + TEST(rManager.getUserRoutes().empty(),("Found User Routes before test start")); +} + +} \ No newline at end of file diff --git a/map/routing_manager.cpp b/map/routing_manager.cpp index 7f2df863ce..2a469d87bc 100644 --- a/map/routing_manager.cpp +++ b/map/routing_manager.cpp @@ -50,6 +50,8 @@ double const kRouteScaleMultiplier = 1.5; string const kRoutePointsFile = "route_points.dat"; +string const kUserRoutesFolder = "user_routes/"; + uint32_t constexpr kInvalidTransactionId = 0; void FillTurnsDistancesForRendering(vector const & segments, @@ -109,7 +111,7 @@ RouteMarkData GetLastPassedPoint(BookmarkManager * bmManager, vector(data.m_pointType)); @@ -117,7 +119,8 @@ void SerializeRoutePoint(json_t * node, RouteMarkData const & data) ToJSONObject(*node, "subtitle", data.m_subTitle); ToJSONObject(*node, "x", data.m_position.x); ToJSONObject(*node, "y", data.m_position.y); - ToJSONObject(*node, "replaceWithMyPosition", data.m_replaceWithMyPositionAfterRestart); + ToJSONObject(*node, "replaceWithMyPosition", + keepReplaceWithMyPositionAfterRestart ? data.m_replaceWithMyPositionAfterRestart : false); } RouteMarkData DeserializeRoutePoint(json_t * node) @@ -140,18 +143,18 @@ RouteMarkData DeserializeRoutePoint(json_t * node) return data; } -string SerializeRoutePoints(vector const & points) +string SerializeRoutePoints(vector const & points, bool const keepReplaceWithMyPositionAfterRestart) { ASSERT_GREATER_OR_EQUAL(points.size(), 2, ()); auto pointsNode = base::NewJSONArray(); for (auto const & p : points) { auto pointNode = base::NewJSONObject(); - SerializeRoutePoint(pointNode.get(), p); + SerializeRoutePoint(pointNode.get(), p, keepReplaceWithMyPositionAfterRestart); json_array_append_new(pointsNode.get(), pointNode.release()); } unique_ptr buffer( - json_dumps(pointsNode.get(), JSON_COMPACT)); + json_dumps(pointsNode.get(), JSON_COMPACT | JSON_ENSURE_ASCII)); return string(buffer.get()); } @@ -1356,31 +1359,56 @@ void RoutingManager::CancelRoutePointsTransaction(uint32_t transactionId) routePoints.AddRoutePoint(std::move(markData)); } +bool RoutingManager::HasSavedUserRoute(string const fileName) const +{ + return HasSavedRoutePoints(kUserRoutesFolder + fileName + ".dat"); +} + + bool RoutingManager::HasSavedRoutePoints() const { - auto const fileName = GetPlatform().SettingsPathForFile(kRoutePointsFile); - return GetPlatform().IsFileExistsByFullPath(fileName); + return HasSavedRoutePoints(kRoutePointsFile); +} + +bool RoutingManager::HasSavedRoutePoints(string const fileName) const +{ + auto const filePath = GetPlatform().SettingsPathForFile(fileName); + return GetPlatform().IsFileExistsByFullPath(filePath); +} + +void RoutingManager::LoadUserRoutePoints(LoadRouteHandler const & handler, string const fileName) +{ + LoadRoutePoints(handler, kUserRoutesFolder + fileName + ".dat", false); } void RoutingManager::LoadRoutePoints(LoadRouteHandler const & handler) { - GetPlatform().RunTask(Platform::Thread::File, [this, handler]() + LoadRoutePoints(handler, kRoutePointsFile, true); +} + +void RoutingManager::LoadRoutePoints(LoadRouteHandler const & handler, string const & fileName, bool const deleteAfterLoading) +{ + GetPlatform().RunTask(Platform::Thread::File, [this, handler, fileName, deleteAfterLoading]() { - if (!HasSavedRoutePoints()) + if (!HasSavedRoutePoints(fileName)) { if (handler) handler(false /* success */); return; } - // Delete file after loading. - auto const fileName = GetPlatform().SettingsPathForFile(kRoutePointsFile); - SCOPE_GUARD(routePointsFileGuard, bind(&FileWriter::DeleteFileX, cref(fileName))); + auto const filePath = GetPlatform().SettingsPathForFile(fileName); + // define a lambda to delete the file based on deleteAfterLoading + auto conditionalDelete = [&]() + { + if (deleteAfterLoading) FileWriter::DeleteFileX(filePath); + }; + SCOPE_GUARD(routePointsFileGuard, conditionalDelete); string data; try { - ReaderPtr(GetPlatform().GetReader(fileName)).ReadAsString(data); + ReaderPtr(GetPlatform().GetReader(filePath)).ReadAsString(data); } catch (RootException const & ex) { @@ -1437,22 +1465,30 @@ void RoutingManager::LoadRoutePoints(LoadRouteHandler const & handler) }); } -void RoutingManager::SaveRoutePoints() +void RoutingManager::SaveUserRoutePoints(string const fileName) { + SaveRoutePoints(kUserRoutesFolder + fileName + ".dat", false); +} + +void RoutingManager::SaveRoutePoints() { + SaveRoutePoints(kRoutePointsFile, true); +} + +void RoutingManager::SaveRoutePoints(string const fileName, bool const keepReplaceWithMyPositionAfterRestart) { auto points = GetRoutePointsToSave(); if (points.empty()) { - DeleteSavedRoutePoints(); + DeleteSavedRoutePoints(fileName); return; } - GetPlatform().RunTask(Platform::Thread::File, [points = std::move(points)]() + GetPlatform().RunTask(Platform::Thread::File, [points = std::move(points), fileName, keepReplaceWithMyPositionAfterRestart]() { try { - auto const fileName = GetPlatform().SettingsPathForFile(kRoutePointsFile); - FileWriter writer(fileName); - string const pointsData = SerializeRoutePoints(points); + auto const filePath = GetPlatform().SettingsPathForFile(fileName); + FileWriter writer(filePath); + string const pointsData = SerializeRoutePoints(points, keepReplaceWithMyPositionAfterRestart); writer.Write(pointsData.c_str(), pointsData.length()); } catch (RootException const & ex) @@ -1501,18 +1537,60 @@ void RoutingManager::OnExtrapolatedLocationUpdate(location::GpsInfo const & info routeMatchingInfo); } +void RoutingManager::DeleteUserRoute(string const fileName) +{ + DeleteSavedRoutePoints(kUserRoutesFolder + fileName + ".dat"); +} + void RoutingManager::DeleteSavedRoutePoints() { - if (!HasSavedRoutePoints()) + DeleteSavedRoutePoints(kRoutePointsFile); +} + +void RoutingManager::DeleteSavedRoutePoints(string const fileName) +{ + if (!HasSavedRoutePoints(fileName)) return; - GetPlatform().RunTask(Platform::Thread::File, []() + GetPlatform().RunTask(Platform::Thread::File, [fileName = fileName]() { - auto const fileName = GetPlatform().SettingsPathForFile(kRoutePointsFile); - FileWriter::DeleteFileX(fileName); + auto const filePath = GetPlatform().SettingsPathForFile(fileName); + FileWriter::DeleteFileX(filePath); }); } +void RoutingManager::RenameUserRoute(string const oldFileName, string const newFileName) +{ + if (!HasSavedRoutePoints(kUserRoutesFolder + oldFileName + ".dat")) + return; + + if (HasSavedRoutePoints(kUserRoutesFolder + newFileName + ".dat")) + return; + + GetPlatform().RunTask(Platform::Thread::File, [oldFileName = kUserRoutesFolder + oldFileName + ".dat" , + newFileName = kUserRoutesFolder + newFileName + ".dat"]() + { + auto const oldPath = GetPlatform().SettingsPathForFile(oldFileName); + auto const newPath = GetPlatform().SettingsPathForFile(newFileName); + base::RenameFileX(oldPath, newPath); + }); +} + +vector RoutingManager::getUserRoutes() +{ + vector routeNames; + GetPlatform().GetFilesByExt(GetPlatform().SettingsPathForFile(kUserRoutesFolder), ".dat", routeNames); + + for(auto name : routeNames) + { + size_t idx = name.rfind(".dat"); + if (idx == string::npos) + continue; + name.erase(idx, 4); // erase file extension from the string + } + return routeNames/*TODO find out how this return value is able to be interpreted in java*/; +} + void RoutingManager::UpdatePreviewMode() { SetSubroutesVisibility(false /* visible */); diff --git a/map/routing_manager.hpp b/map/routing_manager.hpp index 2b42c5781d..f0b80457b7 100644 --- a/map/routing_manager.hpp +++ b/map/routing_manager.hpp @@ -304,16 +304,36 @@ public: void CancelRoutePointsTransaction(uint32_t transactionId); static uint32_t InvalidRoutePointsTransactionId(); - /// \returns true if there are route points saved in file and false otherwise. + /// \returns true if there is a user route points saved with the given name and false otherwise. + bool HasSavedUserRoute(std::string fileName) const; + /// \returns true if there are route points saved in the default file and false otherwise. bool HasSavedRoutePoints() const; - /// \brief It loads road points from file and delete file after loading. + /// \returns true if there are route points saved in file and false otherwise. + bool HasSavedRoutePoints(std::string fileName) const; /// The result of the loading will be sent via SafeCallback. using LoadRouteHandler = platform::SafeCallback; + /// \brief It loads road points from file in a user routes folder and keeps file after loading. + void LoadUserRoutePoints(LoadRouteHandler const & handler, std::string fileName); + /// \brief It loads road points from file and delete file after loading. void LoadRoutePoints(LoadRouteHandler const & handler); - /// \brief It saves route points to file. + /// \brief It loads road points from file and can be set to delete file after loading. + void LoadRoutePoints(LoadRouteHandler const & handler, std::string const& fileName, bool deleteAfterLoading); + /// \brief It saves route points to file in a user routes folder + void SaveUserRoutePoints(std::string fileName); + /// \brief It saves route points to default file. void SaveRoutePoints(); - /// \brief It deletes file with saved route points if it exists. + /// \brief It saves route points to file with the given name. + void SaveRoutePoints(std::string fileName, bool keepReplaceWithMyPositionAfterRestart); + /// \brief It deletes the user route with the user route with the given name if it exists. + void DeleteUserRoute(std::string fileName); + /// \brief It deletes the default file with saved route points if it exists. void DeleteSavedRoutePoints(); + /// \brief It deletes file with saved route points if it exists. + void DeleteSavedRoutePoints(std::string fileName); + /// \brief It renames a user route + void RenameUserRoute(std::string oldFileName, std::string newFileName); + /// \returns names of the files in the user routes folder without the .dat file extension. + std::vector getUserRoutes(); void UpdatePreviewMode(); void CancelPreviewMode(); -- 2.45.3 From 74fac52d5e264889dc7ced107316aebcf88595d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?F=C3=A1bio=20Gomes?= Date: Thu, 23 May 2024 13:10:16 +0100 Subject: [PATCH 2/8] Fix missing newline at the end of test file MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Fábio Gomes --- CONTRIBUTORS | 1 + map/map_tests/user_routes_test.cpp | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 80b7df683e..9fa285fc6b 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -40,6 +40,7 @@ Code contributions: Konstantin Pastbin Nishant Bhandari Sebastiao Sousa + Fábio Gomes Porting to Tizen platform: Sergey Pisarchik diff --git a/map/map_tests/user_routes_test.cpp b/map/map_tests/user_routes_test.cpp index 639e5de87d..38f535dd94 100644 --- a/map/map_tests/user_routes_test.cpp +++ b/map/map_tests/user_routes_test.cpp @@ -39,4 +39,4 @@ UNIT_TEST(user_routes_test) TEST(rManager.getUserRoutes().empty(),("Found User Routes before test start")); } -} \ No newline at end of file +} -- 2.45.3 From 3f4b28704c2306059d08aa2a53e382c841b35bd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?F=C3=A1bio=20Gomes?= Date: Sun, 26 May 2024 15:02:42 +0100 Subject: [PATCH 3/8] [map] Add tests for user routes Add more complete tests for user routes Fix some issues found through the tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Fábio Gomes --- map/map_tests/user_routes_test.cpp | 229 ++++++++++++++++++++++++++++- map/routing_manager.cpp | 43 +++--- map/routing_manager.hpp | 22 +-- 3 files changed, 260 insertions(+), 34 deletions(-) diff --git a/map/map_tests/user_routes_test.cpp b/map/map_tests/user_routes_test.cpp index 38f535dd94..c8f026d5d7 100644 --- a/map/map_tests/user_routes_test.cpp +++ b/map/map_tests/user_routes_test.cpp @@ -1,14 +1,25 @@ #include "testing/testing.hpp" #include "map/routing_manager.hpp" +#include "map/routing_mark.hpp" + +#include "geometry/point2d.hpp" #include #include +#include +#include +#include namespace user_routes_test { using namespace std; +using Runner = Platform::ThreadRunner; + +string const kTestRouteName1 = "My Test Route"; +string const kTestRouteName2 = "My Other Test Route"; + #define RM_CALLBACKS { \ static_cast(nullptr), \ static_cast(nullptr), \ @@ -17,6 +28,86 @@ using namespace std; static_cast(nullptr) \ } +#define BM_CALLBACKS { \ + []() -> StringsBundle const & \ + { \ + static StringsBundle const dummyBundle; \ + return dummyBundle; \ + }, \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr), \ + static_cast(nullptr) \ + } + +RouteMarkData getRouteMarkStart() +{ + RouteMarkData mark; + mark.m_title = "Title 1"; + mark.m_subTitle = "Sub 1"; + mark.m_position.x = 0; + mark.m_position.y = 0; + mark.m_pointType = RouteMarkType::Start; + + return mark; +} + +RouteMarkData getRouteMarkFinish() +{ + RouteMarkData mark; + mark.m_title = "Title 2"; + mark.m_subTitle = "Sub 2"; + mark.m_position.x = 1; + mark.m_position.y = 1; + mark.m_pointType = RouteMarkType::Finish; + + return mark; +} + +void awaitFileSaving(RoutingManager *rManager, string routeName) +{ + for(int i = 1; i <= 5; i++) + { + cout << "Awaiting file saving " << i << endl; + if (rManager->HasSavedUserRoute(routeName)) + { + cout << routeName << " found" << endl; + return; + } + this_thread::sleep_for(chrono::seconds(1)); + } +} + +void awaitFileDeletion(RoutingManager *rManager, string routeName) +{ + for(int i = 1; i <= 5; i++) + { + cout << "Awaiting file deletion " << i << endl; + if (!rManager->HasSavedUserRoute(routeName)) + { + cout << routeName << " deleted" << endl; + return; + } + this_thread::sleep_for(chrono::seconds(1)); + } +} + +void awaitFileLoading(RoutingManager *rManager) +{ + for(int i = 1; i <= 5; i++) + { + cout << "Awaiting file loading " << i << endl; + if (rManager->GetRoutePointsCount() != 0) + { + cout << "Route loaded" << endl; + return; + } + this_thread::sleep_for(chrono::seconds(1)); + } +} + class TestDelegate : public RoutingManager::Delegate { void OnRouteFollow(routing::RouterType type) override @@ -30,13 +121,145 @@ class TestDelegate : public RoutingManager::Delegate } }; -UNIT_TEST(user_routes_test) +UNIT_CLASS_TEST(Runner, user_routes_save_delete) { TestDelegate d = TestDelegate(); TestDelegate & dRef = d; RoutingManager rManager(RM_CALLBACKS, dRef); - - TEST(rManager.getUserRoutes().empty(),("Found User Routes before test start")); + BookmarkManager bmManager(BM_CALLBACKS); + rManager.SetBookmarkManager(&bmManager); + + rManager.AddRoutePoint(getRouteMarkStart()); + rManager.AddRoutePoint(getRouteMarkFinish()); + + TEST(RoutingManager::GetUserRouteNames().empty(),("User routes found before test start")); + + rManager.SaveUserRoutePoints(kTestRouteName1); + awaitFileSaving(&rManager, kTestRouteName1); + + TEST(rManager.HasSavedUserRoute(kTestRouteName1), ("Test route not found after saving it")); + + rManager.DeleteUserRoute(kTestRouteName1); + awaitFileDeletion(&rManager, kTestRouteName1); + + TEST(!rManager.HasSavedUserRoute(kTestRouteName1), ("Test route found after deleting it")); } +UNIT_CLASS_TEST(Runner, user_routes_rename) +{ + TestDelegate d = TestDelegate(); + TestDelegate & dRef = d; + RoutingManager rManager(RM_CALLBACKS, dRef); + BookmarkManager bmManager(BM_CALLBACKS); + rManager.SetBookmarkManager(&bmManager); + + rManager.AddRoutePoint(getRouteMarkStart()); + rManager.AddRoutePoint(getRouteMarkFinish()); + + TEST(RoutingManager::GetUserRouteNames().empty(),("User routes found before test start")); + + rManager.SaveUserRoutePoints(kTestRouteName1); + awaitFileSaving(&rManager, kTestRouteName1); + + TEST(rManager.HasSavedUserRoute(kTestRouteName1), ("Test route 1 not found after saving it")); + TEST(!rManager.HasSavedUserRoute(kTestRouteName2), ("Test route 2 found before naming it that")); + + rManager.RenameUserRoute(kTestRouteName1, kTestRouteName2); + awaitFileSaving(&rManager, kTestRouteName2); + + TEST(!rManager.HasSavedUserRoute(kTestRouteName1), ("Test route 1 found after renaming it")); + TEST(rManager.HasSavedUserRoute(kTestRouteName2), ("Test route 2 not found after naming it that")); + + rManager.DeleteUserRoute(kTestRouteName2); + awaitFileDeletion(&rManager, kTestRouteName2); + + TEST(!rManager.HasSavedUserRoute(kTestRouteName1), ("Test route 1 found after deleting it")); + TEST(!rManager.HasSavedUserRoute(kTestRouteName2), ("Test route 2 found after deleting it")); } + +UNIT_CLASS_TEST(Runner, user_routes_list) +{ + TestDelegate d = TestDelegate(); + TestDelegate & dRef = d; + RoutingManager rManager(RM_CALLBACKS, dRef); + BookmarkManager bmManager(BM_CALLBACKS); + rManager.SetBookmarkManager(&bmManager); + + rManager.AddRoutePoint(getRouteMarkStart()); + rManager.AddRoutePoint(getRouteMarkFinish()); + + TEST(RoutingManager::GetUserRouteNames().empty(),("User routes found before test start")); + + rManager.SaveUserRoutePoints(kTestRouteName1); + rManager.SaveUserRoutePoints(kTestRouteName2); + awaitFileSaving(&rManager, kTestRouteName1); + awaitFileSaving(&rManager, kTestRouteName2); + + TEST(rManager.HasSavedUserRoute(kTestRouteName1), ("Test route 1 not found after saving it")); + TEST(rManager.HasSavedUserRoute(kTestRouteName2), ("Test route 2 not found after saving it")); + + auto routes = RoutingManager::GetUserRouteNames(); + + TEST_EQUAL(routes.size(), 2, ("Incorrect number of routes found")); + + set routesSet(routes.begin(), routes.end()); + + set expectedRoutes; + expectedRoutes.insert(kTestRouteName1); + expectedRoutes.insert(kTestRouteName2); + + TEST_EQUAL(routesSet, expectedRoutes, ("Unexpected route names found")); + + rManager.DeleteUserRoute(kTestRouteName1); + rManager.DeleteUserRoute(kTestRouteName2); + awaitFileDeletion(&rManager, kTestRouteName1); + awaitFileDeletion(&rManager, kTestRouteName2); + + TEST(RoutingManager::GetUserRouteNames().empty(),("Found User Routes after deletion")); +} + +// TODO Solve problems regarding LoadRoutePoints' use of Platform::Thread::Gui, code inside it seems not to be running +/*UNIT_CLASS_TEST(Runner, user_routes_load) +{ + TestDelegate d = TestDelegate(); + TestDelegate & dRef = d; + RoutingManager rManager(RM_CALLBACKS, dRef); + BookmarkManager bmManager(BM_CALLBACKS); + rManager.SetBookmarkManager(&bmManager); + + rManager.AddRoutePoint(getRouteMarkStart()); + rManager.AddRoutePoint(getRouteMarkFinish()); + + TEST(RoutingManager::GetUserRouteNames().empty(),("User routes found before test start")); + + rManager.SaveUserRoutePoints(kTestRouteName1); + awaitFileSaving(&rManager, kTestRouteName1); + + TEST(rManager.HasSavedUserRoute(kTestRouteName1), ("Test route not found after saving it")); + + rManager.RemoveRoutePoints(); + + TEST(rManager.GetRoutePoints().empty(), ("Route points found before loading")); + + rManager.LoadUserRoutePoints(nullptr, kTestRouteName1); + awaitFileLoading(&rManager); + + TEST_EQUAL(rManager.GetRoutePoints().size(), 2, ("Test route loaded incorrect number of points")); + + for (const auto& point : rManager.GetRoutePoints()) + { + if (point.m_pointType == RouteMarkType::Start) + TEST_EQUAL(point.m_position, m2::PointD(0,0), ("Start point incorrect")); + else if (point.m_pointType == RouteMarkType::Finish) + TEST_EQUAL(point.m_position, m2::PointD(1,1), ("Finish point incorrect")); + else + TEST(false, ("Intermediate point found on a 2 point route")); + } + + rManager.DeleteUserRoute(kTestRouteName1); + awaitFileDeletion(&rManager, kTestRouteName1); + + TEST(!rManager.HasSavedUserRoute(kTestRouteName1), ("Test route found after deleting it")); +}*/ + +} // namespace user_routes_test diff --git a/map/routing_manager.cpp b/map/routing_manager.cpp index 2a469d87bc..8eff20b313 100644 --- a/map/routing_manager.cpp +++ b/map/routing_manager.cpp @@ -50,7 +50,7 @@ double const kRouteScaleMultiplier = 1.5; string const kRoutePointsFile = "route_points.dat"; -string const kUserRoutesFolder = "user_routes/"; +string const kUserRoutesFileExtension = ".usrdat"; uint32_t constexpr kInvalidTransactionId = 0; @@ -1359,9 +1359,9 @@ void RoutingManager::CancelRoutePointsTransaction(uint32_t transactionId) routePoints.AddRoutePoint(std::move(markData)); } -bool RoutingManager::HasSavedUserRoute(string const fileName) const +bool RoutingManager::HasSavedUserRoute(string const routeName) const { - return HasSavedRoutePoints(kUserRoutesFolder + fileName + ".dat"); + return HasSavedRoutePoints(routeName + kUserRoutesFileExtension); } @@ -1376,9 +1376,9 @@ bool RoutingManager::HasSavedRoutePoints(string const fileName) const return GetPlatform().IsFileExistsByFullPath(filePath); } -void RoutingManager::LoadUserRoutePoints(LoadRouteHandler const & handler, string const fileName) +void RoutingManager::LoadUserRoutePoints(LoadRouteHandler const & handler, string const routeName) { - LoadRoutePoints(handler, kUserRoutesFolder + fileName + ".dat", false); + LoadRoutePoints(handler, routeName + kUserRoutesFileExtension, false); } void RoutingManager::LoadRoutePoints(LoadRouteHandler const & handler) @@ -1465,8 +1465,9 @@ void RoutingManager::LoadRoutePoints(LoadRouteHandler const & handler, string co }); } -void RoutingManager::SaveUserRoutePoints(string const fileName) { - SaveRoutePoints(kUserRoutesFolder + fileName + ".dat", false); +void RoutingManager::SaveUserRoutePoints(string const routeName) +{ + SaveRoutePoints(routeName + kUserRoutesFileExtension, false); } void RoutingManager::SaveRoutePoints() { @@ -1537,9 +1538,9 @@ void RoutingManager::OnExtrapolatedLocationUpdate(location::GpsInfo const & info routeMatchingInfo); } -void RoutingManager::DeleteUserRoute(string const fileName) +void RoutingManager::DeleteUserRoute(string const routeName) { - DeleteSavedRoutePoints(kUserRoutesFolder + fileName + ".dat"); + DeleteSavedRoutePoints(routeName + kUserRoutesFileExtension); } void RoutingManager::DeleteSavedRoutePoints() @@ -1559,16 +1560,16 @@ void RoutingManager::DeleteSavedRoutePoints(string const fileName) }); } -void RoutingManager::RenameUserRoute(string const oldFileName, string const newFileName) +void RoutingManager::RenameUserRoute(string const oldRouteName, string const newRouteName) { - if (!HasSavedRoutePoints(kUserRoutesFolder + oldFileName + ".dat")) + if (!HasSavedRoutePoints(oldRouteName + kUserRoutesFileExtension)) return; - if (HasSavedRoutePoints(kUserRoutesFolder + newFileName + ".dat")) + if (HasSavedRoutePoints(newRouteName + kUserRoutesFileExtension)) return; - GetPlatform().RunTask(Platform::Thread::File, [oldFileName = kUserRoutesFolder + oldFileName + ".dat" , - newFileName = kUserRoutesFolder + newFileName + ".dat"]() + GetPlatform().RunTask(Platform::Thread::File, [oldFileName = oldRouteName + kUserRoutesFileExtension , + newFileName = newRouteName + kUserRoutesFileExtension]() { auto const oldPath = GetPlatform().SettingsPathForFile(oldFileName); auto const newPath = GetPlatform().SettingsPathForFile(newFileName); @@ -1576,19 +1577,21 @@ void RoutingManager::RenameUserRoute(string const oldFileName, string const newF }); } -vector RoutingManager::getUserRoutes() +// static +vector RoutingManager::GetUserRouteNames() { + vector routeFileNames; vector routeNames; - GetPlatform().GetFilesByExt(GetPlatform().SettingsPathForFile(kUserRoutesFolder), ".dat", routeNames); + Platform::GetFilesByExt(GetPlatform().SettingsDir(), kUserRoutesFileExtension, routeFileNames); - for(auto name : routeNames) + for(const auto & name : routeFileNames) { - size_t idx = name.rfind(".dat"); + size_t idx = name.rfind(kUserRoutesFileExtension); if (idx == string::npos) continue; - name.erase(idx, 4); // erase file extension from the string + routeNames.push_back(name.substr(0, idx)); // string without extension } - return routeNames/*TODO find out how this return value is able to be interpreted in java*/; + return routeNames; } void RoutingManager::UpdatePreviewMode() diff --git a/map/routing_manager.hpp b/map/routing_manager.hpp index f0b80457b7..ec5ae6258d 100644 --- a/map/routing_manager.hpp +++ b/map/routing_manager.hpp @@ -304,36 +304,36 @@ public: void CancelRoutePointsTransaction(uint32_t transactionId); static uint32_t InvalidRoutePointsTransactionId(); - /// \returns true if there is a user route points saved with the given name and false otherwise. - bool HasSavedUserRoute(std::string fileName) const; + /// \returns true if there is a user route saved with the given name and false otherwise. + bool HasSavedUserRoute(std::string routeName) const; /// \returns true if there are route points saved in the default file and false otherwise. bool HasSavedRoutePoints() const; /// \returns true if there are route points saved in file and false otherwise. bool HasSavedRoutePoints(std::string fileName) const; /// The result of the loading will be sent via SafeCallback. using LoadRouteHandler = platform::SafeCallback; - /// \brief It loads road points from file in a user routes folder and keeps file after loading. - void LoadUserRoutePoints(LoadRouteHandler const & handler, std::string fileName); + /// \brief It loads road points from file with a user routes file extension and keeps file after loading. + void LoadUserRoutePoints(LoadRouteHandler const & handler, std::string routeName); /// \brief It loads road points from file and delete file after loading. void LoadRoutePoints(LoadRouteHandler const & handler); /// \brief It loads road points from file and can be set to delete file after loading. void LoadRoutePoints(LoadRouteHandler const & handler, std::string const& fileName, bool deleteAfterLoading); - /// \brief It saves route points to file in a user routes folder - void SaveUserRoutePoints(std::string fileName); + /// \brief It saves route points to file with a user routes file extension + void SaveUserRoutePoints(std::string routeName); /// \brief It saves route points to default file. void SaveRoutePoints(); /// \brief It saves route points to file with the given name. void SaveRoutePoints(std::string fileName, bool keepReplaceWithMyPositionAfterRestart); - /// \brief It deletes the user route with the user route with the given name if it exists. - void DeleteUserRoute(std::string fileName); + /// \brief It deletes the user route with the given name if it exists. + void DeleteUserRoute(std::string routeName); /// \brief It deletes the default file with saved route points if it exists. void DeleteSavedRoutePoints(); /// \brief It deletes file with saved route points if it exists. void DeleteSavedRoutePoints(std::string fileName); /// \brief It renames a user route - void RenameUserRoute(std::string oldFileName, std::string newFileName); - /// \returns names of the files in the user routes folder without the .dat file extension. - std::vector getUserRoutes(); + void RenameUserRoute(std::string oldRouteName, std::string newRouteName); + /// \returns names of the files with a user routes file extension without the .usrdat file extension. + static std::vector GetUserRouteNames(); void UpdatePreviewMode(); void CancelPreviewMode(); -- 2.45.3 From ea4da2a82a87e42736ce3f39692cb9343e30883c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?F=C3=A1bio=20Gomes?= Date: Fri, 21 Jun 2024 09:54:23 +0100 Subject: [PATCH 4/8] [routing] Make GetUserRouteNames return an ordered vector MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Fábio Gomes --- map/routing_manager.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/map/routing_manager.cpp b/map/routing_manager.cpp index 8eff20b313..30e7f54d06 100644 --- a/map/routing_manager.cpp +++ b/map/routing_manager.cpp @@ -1591,6 +1591,13 @@ vector RoutingManager::GetUserRouteNames() continue; routeNames.push_back(name.substr(0, idx)); // string without extension } + auto compareFunc = [](string s1, string s2) + { + std::transform(s1.begin(), s1.end(), s1.begin(), ::toupper); + std::transform(s2.begin(), s2.end(), s2.begin(), ::toupper); + return s1.compare(s2) < 0; + }; + std::sort(routeNames.begin(), routeNames.end(), compareFunc); return routeNames; } -- 2.45.3 From 7ab0c25a1369ed819e90dceebee47d561c5a21e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?F=C3=A1bio=20Gomes?= Date: Fri, 21 Jun 2024 09:57:21 +0100 Subject: [PATCH 5/8] [android] Add native function for user routes feature MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Fábio Gomes --- .../main/cpp/app/organicmaps/Framework.cpp | 37 +++++++++++++++++++ .../main/java/app/organicmaps/Framework.java | 7 ++++ 2 files changed, 44 insertions(+) diff --git a/android/app/src/main/cpp/app/organicmaps/Framework.cpp b/android/app/src/main/cpp/app/organicmaps/Framework.cpp index 371d503a20..643a87a92d 100644 --- a/android/app/src/main/cpp/app/organicmaps/Framework.cpp +++ b/android/app/src/main/cpp/app/organicmaps/Framework.cpp @@ -1854,6 +1854,43 @@ Java_app_organicmaps_Framework_nativeDeleteSavedRoutePoints(JNIEnv *, jclass) frm()->GetRoutingManager().DeleteSavedRoutePoints(); } +JNIEXPORT jboolean JNICALL +Java_app_organicmaps_Framework_nativeHasSavedUserRoute(JNIEnv * env, jclass, jstring routeName) +{ + return frm()->GetRoutingManager().HasSavedUserRoute(jni::ToNativeString(env, routeName)); +} + +JNIEXPORT void JNICALL +Java_app_organicmaps_Framework_nativeLoadUserRoutePoints(JNIEnv * env, jclass, jstring routeName) +{ + frm()->GetRoutingManager().LoadUserRoutePoints(g_loadRouteHandler, jni::ToNativeString(env, routeName)); +} + +JNIEXPORT void JNICALL +Java_app_organicmaps_Framework_nativeSaveUserRoutePoints(JNIEnv * env, jclass, jstring routeName) +{ + frm()->GetRoutingManager().SaveUserRoutePoints(jni::ToNativeString(env, routeName)); +} + +JNIEXPORT void JNICALL +Java_app_organicmaps_Framework_nativeDeleteUserRoute(JNIEnv * env, jclass, jstring routeName) +{ + frm()->GetRoutingManager().DeleteUserRoute(jni::ToNativeString(env, routeName)); +} + +JNIEXPORT void JNICALL +Java_app_organicmaps_Framework_nativeRenameUserRoute(JNIEnv * env, jclass, jstring oldRouteName, jstring newRouteName) +{ + frm()->GetRoutingManager().RenameUserRoute(jni::ToNativeString(env, oldRouteName), jni::ToNativeString(env, newRouteName)); +} + +JNIEXPORT jobjectArray JNICALL +Java_app_organicmaps_Framework_nativeGetUserRouteNames(JNIEnv * env, jclass) +{ + auto routeNames = frm()->GetRoutingManager().GetUserRouteNames(); + return jni::ToJavaStringArray(env, routeNames); +} + JNIEXPORT void JNICALL Java_app_organicmaps_Framework_nativeShowFeature(JNIEnv * env, jclass, jobject featureId) { diff --git a/android/app/src/main/java/app/organicmaps/Framework.java b/android/app/src/main/java/app/organicmaps/Framework.java index 76c09d6d7b..8ca94cc63f 100644 --- a/android/app/src/main/java/app/organicmaps/Framework.java +++ b/android/app/src/main/java/app/organicmaps/Framework.java @@ -421,6 +421,13 @@ public class Framework public static native void nativeSaveRoutePoints(); public static native void nativeDeleteSavedRoutePoints(); + public static native boolean nativeHasSavedUserRoute(@NonNull String routeName); + public static native void nativeLoadUserRoutePoints(@NonNull String routeName); + public static native void nativeSaveUserRoutePoints(@NonNull String routeName); + public static native void nativeDeleteUserRoute(@NonNull String routeName); + public static native void nativeRenameUserRoute(@NonNull String oldRouteName, @NonNull String newRouteName); + public static native String[] nativeGetUserRouteNames(); + public static native void nativeShowFeature(@NonNull FeatureId featureId); public static native void nativeMakeCrash(); -- 2.45.3 From a1cb87bca6428e21c96e40929f80c573b2ebed3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?F=C3=A1bio=20Gomes?= Date: Fri, 21 Jun 2024 10:12:34 +0100 Subject: [PATCH 6/8] [android] Add UI elements for user route management MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit For users to interact with this feature the following was added: - Button in the map screen to enter a bottom sheet menu - Fragment for the bottom sheet menu. Contains a button to save the selected route, the button is disabled if there are not enough route points; a recycle view with an item for each user route. - A route item contains a button with the name of the route, used to load the route points; a button to rename the route; and a button to delete the route. Checks are in place to confirm before deleting a route or overwriting an existing one. Notes: - The map screen button has a placeholder icon and a placeholder location when not in navigation mode. - All the text is still hard coded in English and is to be implemented correctly shortly. - It might make sense to move this from a bottom sheet next to the bookmarks, as to keep every user saved element together. Signed-off-by: Fábio Gomes --- .../java/app/organicmaps/MwmActivity.java | 12 +- .../maplayer/MapButtonsController.java | 17 +- .../maplayer/MyRoutesFragment.java | 265 ++++++++++++++++++ .../maplayer/RouteBottomSheetItem.java | 58 ++++ .../app/organicmaps/maplayer/RouteHolder.java | 59 ++++ .../organicmaps/maplayer/RoutesAdapter.java | 83 ++++++ .../map_buttons_layout_planning.xml | 8 + .../map_buttons_layout_regular.xml | 8 + .../src/main/res/layout/fragment_myroutes.xml | 65 +++++ .../main/res/layout/item_myroute_button.xml | 50 ++++ .../layout/map_buttons_layout_planning.xml | 55 ++-- .../res/layout/map_buttons_layout_regular.xml | 7 + .../main/res/layout/map_buttons_myroutes.xml | 8 + 13 files changed, 671 insertions(+), 24 deletions(-) create mode 100644 android/app/src/main/java/app/organicmaps/maplayer/MyRoutesFragment.java create mode 100644 android/app/src/main/java/app/organicmaps/maplayer/RouteBottomSheetItem.java create mode 100644 android/app/src/main/java/app/organicmaps/maplayer/RouteHolder.java create mode 100644 android/app/src/main/java/app/organicmaps/maplayer/RoutesAdapter.java create mode 100644 android/app/src/main/res/layout/fragment_myroutes.xml create mode 100644 android/app/src/main/res/layout/item_myroute_button.xml create mode 100644 android/app/src/main/res/layout/map_buttons_myroutes.xml diff --git a/android/app/src/main/java/app/organicmaps/MwmActivity.java b/android/app/src/main/java/app/organicmaps/MwmActivity.java index b584bbb15f..1f834e35ce 100644 --- a/android/app/src/main/java/app/organicmaps/MwmActivity.java +++ b/android/app/src/main/java/app/organicmaps/MwmActivity.java @@ -72,6 +72,7 @@ import app.organicmaps.location.SensorHelper; import app.organicmaps.location.SensorListener; import app.organicmaps.maplayer.MapButtonsController; import app.organicmaps.maplayer.MapButtonsViewModel; +import app.organicmaps.maplayer.MyRoutesFragment; import app.organicmaps.maplayer.ToggleMapLayerFragment; import app.organicmaps.maplayer.isolines.IsolinesManager; import app.organicmaps.maplayer.isolines.IsolinesState; @@ -156,6 +157,7 @@ public class MwmActivity extends BaseMwmFragmentActivity private static final String MAIN_MENU_ID = "MAIN_MENU_BOTTOM_SHEET"; private static final String LAYERS_MENU_ID = "LAYERS_MENU_BOTTOM_SHEET"; + private static final String MYROUTES_MENU_ID = "MYROUTES_MENU_BOTTOM_SHEET"; @Nullable private MapFragment mMapFragment; @@ -774,6 +776,11 @@ public class MwmActivity extends BaseMwmFragmentActivity showBottomSheet(MAIN_MENU_ID); } case help -> showHelp(); + case myRoutes -> + { + closeFloatingPanels(); + showBottomSheet(MYROUTES_MENU_ID); + } } } @@ -892,6 +899,7 @@ public class MwmActivity extends BaseMwmFragmentActivity { closeBottomSheet(LAYERS_MENU_ID); closeBottomSheet(MAIN_MENU_ID); + closeBottomSheet(MYROUTES_MENU_ID); closePlacePage(); } @@ -1147,7 +1155,7 @@ public class MwmActivity extends BaseMwmFragmentActivity public void onBackPressed() { final RoutingController routingController = RoutingController.get(); - if (!closeBottomSheet(MAIN_MENU_ID) && !closeBottomSheet(LAYERS_MENU_ID) && + if (!closeBottomSheet(MAIN_MENU_ID) && !closeBottomSheet(LAYERS_MENU_ID) && !closeBottomSheet(MYROUTES_MENU_ID) && !collapseNavMenu() && !closePlacePage() && !closeSearchToolbar(true, true) && !closeSidePanel() && !closePositionChooser() && !routingController.resetToPlanningStateIfNavigating() && !routingController.cancel()) @@ -2164,6 +2172,8 @@ public class MwmActivity extends BaseMwmFragmentActivity { if (id.equals(LAYERS_MENU_ID)) return new ToggleMapLayerFragment(); + else if (id.equals(MYROUTES_MENU_ID)) + return new MyRoutesFragment(); return null; } diff --git a/android/app/src/main/java/app/organicmaps/maplayer/MapButtonsController.java b/android/app/src/main/java/app/organicmaps/maplayer/MapButtonsController.java index 94cbbc6f9c..791eca6762 100644 --- a/android/app/src/main/java/app/organicmaps/maplayer/MapButtonsController.java +++ b/android/app/src/main/java/app/organicmaps/maplayer/MapButtonsController.java @@ -44,6 +44,8 @@ public class MapButtonsController extends Fragment private View mBottomButtonsFrame; @Nullable private FloatingActionButton mToggleMapLayerButton; + @Nullable + private FloatingActionButton mMyRoutesButton; @Nullable private MyPositionButton mNavMyPosition; @@ -104,6 +106,11 @@ public class MapButtonsController extends Fragment final View myPosition = mFrame.findViewById(R.id.my_position); mNavMyPosition = new MyPositionButton(myPosition, (v) -> mMapButtonClickListener.onMapButtonClick(MapButtons.myPosition)); + mMyRoutesButton = mFrame.findViewById(R.id.btn_myroutes); + if (mMyRoutesButton != null) + { + mMyRoutesButton.setOnClickListener(view -> mMapButtonClickListener.onMapButtonClick(MapButtons.myRoutes)); + } // Some buttons do not exist in navigation mode mToggleMapLayerButton = mFrame.findViewById(R.id.layers_button); if (mToggleMapLayerButton != null) @@ -143,6 +150,8 @@ public class MapButtonsController extends Fragment mButtonsMap.put(MapButtons.bookmarks, bookmarksButton); mButtonsMap.put(MapButtons.search, searchButton); + if (mMyRoutesButton != null) + mButtonsMap.put(MapButtons.myRoutes, mMyRoutesButton); if (mToggleMapLayerButton != null) mButtonsMap.put(MapButtons.toggleMapLayer, mToggleMapLayerButton); if (menuButton != null) @@ -181,6 +190,11 @@ public class MapButtonsController extends Fragment case bookmarks: case menu: UiUtils.showIf(show, buttonView); + break; + case myRoutes: + UiUtils.showIf(show, mMyRoutesButton); + break; + } } @@ -350,7 +364,8 @@ public class MapButtonsController extends Fragment search, bookmarks, menu, - help + help, + myRoutes } public interface MapButtonClickListener diff --git a/android/app/src/main/java/app/organicmaps/maplayer/MyRoutesFragment.java b/android/app/src/main/java/app/organicmaps/maplayer/MyRoutesFragment.java new file mode 100644 index 0000000000..36ffad97a2 --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/maplayer/MyRoutesFragment.java @@ -0,0 +1,265 @@ +package app.organicmaps.maplayer; + +import android.app.AlertDialog; +import android.os.Bundle; +import android.os.SystemClock; +import android.text.InputFilter; +import android.text.InputType; +import android.view.LayoutInflater; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewGroup; +import android.view.WindowManager; +import android.widget.Button; +import android.widget.EditText; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.fragment.app.Fragment; +import androidx.lifecycle.ViewModelProvider; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; + +import com.google.android.material.button.MaterialButton; + +import java.util.ArrayList; +import java.util.List; + +import app.organicmaps.Framework; +import app.organicmaps.R; +import app.organicmaps.util.bottomsheet.MenuBottomSheetFragment; + +public class MyRoutesFragment extends Fragment +{ + private static final String MYROUTES_MENU_ID = "MYROUTES_MENU_BOTTOM_SHEET"; + @Nullable + private RoutesAdapter mAdapter; + private MapButtonsViewModel mMapButtonsViewModel; + private String mEditText = ""; + private String mDialogCaller = ""; + private RouteBottomSheetItem mCurrentItem = null; + private static final String SAVE_ID = "SAVE_ID"; + private static final String RENAME_ID = "RENAME_ID"; + private static final String DELETE_ID = "DELETE_ID"; + + @Nullable + @Override + public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) + { + View mRoot = inflater.inflate(R.layout.fragment_myroutes, container, false); + + mMapButtonsViewModel = new ViewModelProvider(requireActivity()).get(MapButtonsViewModel.class); + MaterialButton mCloseButton = mRoot.findViewById(R.id.close_button); + mCloseButton.setOnClickListener(view -> closeMyRoutesBottomSheet()); + + Button mSaveButton = mRoot.findViewById(R.id.save_button); + if (Framework.nativeGetRoutePoints().length >= 2) + mSaveButton.setOnClickListener(view -> onSaveButtonClick()); + else + mSaveButton.setEnabled(false); + + initRecycler(mRoot); + return mRoot; + } + + private void initRecycler(@NonNull View root) + { + RecyclerView recycler = root.findViewById(R.id.recycler); + RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(requireContext(), + LinearLayoutManager.VERTICAL, + false); + recycler.setLayoutManager(layoutManager); + mAdapter = new RoutesAdapter(getRouteItems()); + recycler.setAdapter(mAdapter); + recycler.setNestedScrollingEnabled(false); + } + + private List getRouteItems() + { + String[] savedRouteNames = Framework.nativeGetUserRouteNames(); + List items = new ArrayList<>(); + for (String routeName : savedRouteNames) + items.add(createItem(routeName)); + return items; + } + + private RouteBottomSheetItem createItem(String routeName) + { + return RouteBottomSheetItem.create(routeName, this::onItemTitleClick, this::onItemRenameClick, this::onItemDeleteClick); + } + + private void onSaveButtonClick() + { + mEditText = ""; + mDialogCaller = SAVE_ID; + showTextInputDialog(""); + } + + private void checkSave() + { + String newRouteName = mEditText; + + if (newRouteName.isEmpty()) + return; + if (Framework.nativeHasSavedUserRoute(newRouteName)) + { + showConfirmationDialog(newRouteName + " already exists", + "Overwrite existing " + newRouteName + "?", + "Overwrite"); + return; + } + save(false); + } + + private void save(boolean isOverwrite) + { + String newRouteName = mEditText; + + if (isOverwrite) + Framework.nativeDeleteUserRoute(newRouteName); + + Framework.nativeSaveUserRoutePoints(newRouteName); + + if (!isOverwrite) + mAdapter.addRoute(createItem(newRouteName)); + } + + private void onItemTitleClick(@NonNull View v, @NonNull RouteBottomSheetItem item) + { + Framework.nativeLoadUserRoutePoints(item.getRouteName()); + } + + private void onItemRenameClick(@NonNull View v, @NonNull RouteBottomSheetItem item) + { + mEditText = ""; + mDialogCaller = RENAME_ID; + mCurrentItem = item; + showTextInputDialog(item.getRouteName()); + } + + private void checkRename() + { + String newRouteName = mEditText; + + if (newRouteName.isEmpty()) + return; + + if (newRouteName.equals(mCurrentItem.getRouteName())) + return; + if (Framework.nativeHasSavedUserRoute(newRouteName)) + { + showConfirmationDialog(newRouteName + " already exists", + "Overwrite existing " + newRouteName + "?", + "Overwrite"); + return; + } + rename(false); + } + + private void rename(boolean isOverwrite) + { + String newRouteName = mEditText; + + if (isOverwrite) + { + Framework.nativeDeleteUserRoute(newRouteName); + // Sometimes delete takes too long and renaming cannot happen; thus, sleep + SystemClock.sleep(250); // TODO(Fábio Gomes) find a better solution + } + + Framework.nativeRenameUserRoute(mCurrentItem.getRouteName(), newRouteName); + + mAdapter.removeRoute(mCurrentItem); + if (!isOverwrite) + mAdapter.addRoute(createItem(newRouteName)); + } + + private void onItemDeleteClick(@NonNull View v, @NonNull RouteBottomSheetItem item) + { + mDialogCaller = DELETE_ID; + mCurrentItem = item; + showConfirmationDialog("Delete " + item.getRouteName() + "?", + "This action cannot be undone.", + "Delete"); + } + + private void delete() + { + Framework.nativeDeleteUserRoute(mCurrentItem.getRouteName()); + mAdapter.removeRoute(mCurrentItem); + } + + private void closeMyRoutesBottomSheet() + { + MenuBottomSheetFragment bottomSheet = + (MenuBottomSheetFragment) requireActivity().getSupportFragmentManager().findFragmentByTag(MYROUTES_MENU_ID); + if (bottomSheet != null) + bottomSheet.dismiss(); + } + + private void showConfirmationDialog(String title, String message, String buttonText) + { + AlertDialog dialog = new AlertDialog.Builder(this.getContext(), R.style.MwmTheme_AlertDialog) + .setTitle(title) + .setMessage(message) + .setPositiveButton(buttonText, (dialogInterface, i) -> { + switch (mDialogCaller) { + case SAVE_ID -> save(true); + case RENAME_ID -> rename(true); + case DELETE_ID -> delete(); + } + }) + .setNegativeButton("Cancel", (dialogInterface, i) -> { + switch (mDialogCaller) { + case SAVE_ID, RENAME_ID -> retryInput(); + } + }) + .create(); + + dialog.show(); + } + + private void showTextInputDialog(String defaultText) + { + EditText input = new EditText(this.getContext()); + input.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES); + input.setFilters(getInputFilters()); + input.setText(defaultText); + + AlertDialog dialog = new AlertDialog.Builder(this.getContext(), R.style.MwmTheme_AlertDialog) + .setTitle("Route Name") + .setView(input) + .setPositiveButton("OK", (dialogInterface, i) -> { + mEditText = input.getText().toString(); + switch (mDialogCaller) { + case SAVE_ID -> checkSave(); + case RENAME_ID -> checkRename(); + } + }) + .setNegativeButton("Cancel", null) + .create(); + + dialog.show(); + } + + private void retryInput() + { + showTextInputDialog(mEditText); + } + + private InputFilter[] getInputFilters() + { + InputFilter filter = (source, start, end, dest, dstart, dend) -> { + for (int i = start; i < end; i++) + { + char current = source.charAt(i); + if (!Character.isSpaceChar(current) && !Character.isLetterOrDigit(current)) + { + return ""; + } + } + return null; + }; + return new InputFilter[] {filter, new InputFilter.LengthFilter(32)}; + } +} diff --git a/android/app/src/main/java/app/organicmaps/maplayer/RouteBottomSheetItem.java b/android/app/src/main/java/app/organicmaps/maplayer/RouteBottomSheetItem.java new file mode 100644 index 0000000000..b1938f2aad --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/maplayer/RouteBottomSheetItem.java @@ -0,0 +1,58 @@ +package app.organicmaps.maplayer; + +import android.view.View; + +import androidx.annotation.NonNull; + +import app.organicmaps.adapter.OnItemClickListener; + +public class RouteBottomSheetItem +{ + @NonNull + private final String mRouteName; + @NonNull + private final OnItemClickListener mItemTitleClickListener; + @NonNull + private final OnItemClickListener mItemRenameClickListener; + @NonNull + private final OnItemClickListener mItemDeleteClickListener; + + RouteBottomSheetItem(@NonNull String routeName, + @NonNull OnItemClickListener itemTitleClickListener, + @NonNull OnItemClickListener itemRenameClickListener, + @NonNull OnItemClickListener itemDeleteClickListener) + { + mRouteName = routeName; + mItemTitleClickListener = itemTitleClickListener; + mItemRenameClickListener = itemRenameClickListener; + mItemDeleteClickListener = itemDeleteClickListener; + } + + public static RouteBottomSheetItem create(@NonNull String routeName, + @NonNull OnItemClickListener routeItemTitleClickListener, + @NonNull OnItemClickListener routeItemRenameClickListener, + @NonNull OnItemClickListener routeItemDeleteClickListener) + { + return new RouteBottomSheetItem(routeName, routeItemTitleClickListener, routeItemRenameClickListener, routeItemDeleteClickListener); + } + + public String getRouteName() + { + return mRouteName; + } + + public void onTitleClick(@NonNull View v, @NonNull RouteBottomSheetItem item) + { + mItemTitleClickListener.onItemClick(v, item); + } + + public void onRenameClick(@NonNull View v, @NonNull RouteBottomSheetItem item) + { + mItemRenameClickListener.onItemClick(v, item); + } + + public void onDeleteClick(@NonNull View v, @NonNull RouteBottomSheetItem item) + { + mItemDeleteClickListener.onItemClick(v, item); + } +} diff --git a/android/app/src/main/java/app/organicmaps/maplayer/RouteHolder.java b/android/app/src/main/java/app/organicmaps/maplayer/RouteHolder.java new file mode 100644 index 0000000000..1ba70c9fcb --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/maplayer/RouteHolder.java @@ -0,0 +1,59 @@ +package app.organicmaps.maplayer; + +import android.view.View; +import android.widget.ImageView; +import android.widget.TextView; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.recyclerview.widget.RecyclerView; + +import app.organicmaps.R; +import app.organicmaps.adapter.OnItemClickListener; + +class RouteHolder extends RecyclerView.ViewHolder +{ + @NonNull + final TextView mTitle; + @NonNull + final ImageView mRenameButton; + @NonNull + final ImageView mDeleteButton; + @Nullable + RouteBottomSheetItem mItem; + @Nullable + OnItemClickListener mTitleListener; + @Nullable + OnItemClickListener mRenameListener; + @Nullable + OnItemClickListener mDeleteListener; + + RouteHolder(@NonNull View root) + { + super(root); + mTitle = root.findViewById(R.id.name); + mTitle.setOnClickListener(this::onItemTitleClicked); + mRenameButton = root.findViewById(R.id.rename); + mRenameButton.setOnClickListener(this::onItemRenameClicked); + mDeleteButton = root.findViewById(R.id.delete); + mDeleteButton.setOnClickListener(this::onItemDeleteClicked); + } + + public void onItemTitleClicked(@NonNull View v) + { + if (mTitleListener != null && mItem != null) + mTitleListener.onItemClick(v, mItem); + } + + public void onItemRenameClicked(@NonNull View v) + { + if (mRenameListener != null && mItem != null) + mRenameListener.onItemClick(v, mItem); + } + + public void onItemDeleteClicked(@NonNull View v) + { + if (mDeleteListener != null && mItem != null) + mDeleteListener.onItemClick(v, mItem); + } +} diff --git a/android/app/src/main/java/app/organicmaps/maplayer/RoutesAdapter.java b/android/app/src/main/java/app/organicmaps/maplayer/RoutesAdapter.java new file mode 100644 index 0000000000..34ae565ae5 --- /dev/null +++ b/android/app/src/main/java/app/organicmaps/maplayer/RoutesAdapter.java @@ -0,0 +1,83 @@ +package app.organicmaps.maplayer; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.RecyclerView; + +import java.util.List; + +import app.organicmaps.R; +import app.organicmaps.util.SharedPropertiesUtils; +import app.organicmaps.util.UiUtils; +import app.organicmaps.util.log.Logger; + +public class RoutesAdapter extends RecyclerView.Adapter +{ + @NonNull + private final List mItems; + + public RoutesAdapter(@NonNull List items) + { + mItems = items; + } + + @NonNull + @Override + public RouteHolder onCreateViewHolder(ViewGroup parent, int viewType) + { + LayoutInflater inflater = LayoutInflater.from(parent.getContext()); + View root = inflater.inflate(R.layout.item_myroute_button, parent, false); + return new RouteHolder(root); + } + + @Override + public void onBindViewHolder(RouteHolder holder, int position) + { + RouteBottomSheetItem item = mItems.get(position); + holder.mItem = item; + + holder.mTitle.setSelected(true); + holder.mTitle.setText(item.getRouteName()); + + holder.mTitleListener = item::onTitleClick; + holder.mRenameListener = item::onRenameClick; + holder.mDeleteListener = item::onDeleteClick; + } + + @Override + public int getItemCount() + { + return mItems.size(); + } + + public void addRoute(@NonNull RouteBottomSheetItem item) + { + // Compare strings toUpperCase to ignore case + String routeName = item.getRouteName().toUpperCase(); + String iName; + // Find index to add ordered + int pos = mItems.size(); + for (int i = 0; i < mItems.size(); i++) + { + iName = mItems.get(i).getRouteName().toUpperCase(); + if(routeName.compareTo(iName) < 0) + { + pos = i; + break; + } + } + mItems.add(pos, item); + notifyItemInserted(pos); + } + + public void removeRoute(@NonNull RouteBottomSheetItem item) + { + int pos = mItems.indexOf(item); + mItems.remove(item); + notifyItemRemoved(pos); + } +} diff --git a/android/app/src/main/res/layout-h400dp/map_buttons_layout_planning.xml b/android/app/src/main/res/layout-h400dp/map_buttons_layout_planning.xml index b80f476643..d643bceedb 100644 --- a/android/app/src/main/res/layout-h400dp/map_buttons_layout_planning.xml +++ b/android/app/src/main/res/layout-h400dp/map_buttons_layout_planning.xml @@ -33,6 +33,14 @@ android:layout_marginBottom="@dimen/margin_half" app:layout_constraintBottom_toTopOf="@+id/btn_bookmarks" app:layout_constraintStart_toStartOf="parent" /> + + \ No newline at end of file diff --git a/android/app/src/main/res/layout/fragment_myroutes.xml b/android/app/src/main/res/layout/fragment_myroutes.xml new file mode 100644 index 0000000000..4da26f7df9 --- /dev/null +++ b/android/app/src/main/res/layout/fragment_myroutes.xml @@ -0,0 +1,65 @@ + + + + + + +