Format all C++ and Java code via clang-format

Signed-off-by: Konstantin Pastbin <konstantin.pastbin@gmail.com>

android/app/src/main/java/app/organicmaps/DownloadResourcesLegacyActivity.java

@@ -155,9 +155,7 @@ public class DownloadResourcesLegacyActivity extends BaseMwmFragmentActivity
           showMap();
           return;
 
-          case CountryItem.STATUS_FAILED:
+        case CountryItem.STATUS_FAILED: MapManager.showError(DownloadResourcesLegacyActivity.this, item, null); return;
-            MapManager.showError(DownloadResourcesLegacyActivity.this, item, null);
-            return;
         }
       }
     }

android/app/src/main/java/app/organicmaps/downloader/DownloaderFragment.java

@@ -24,8 +24,8 @@ import app.organicmaps.widget.PlaceholderView;
 import java.util.ArrayList;
 import java.util.List;
 
-public class DownloaderFragment extends BaseMwmRecyclerFragment<DownloaderAdapter>
+public class DownloaderFragment
-    implements MenuBottomSheetFragment.MenuBottomSheetInterface
+    extends BaseMwmRecyclerFragment<DownloaderAdapter> implements MenuBottomSheetFragment.MenuBottomSheetInterface
 {
   private DownloaderToolbarController mToolbarController;
 
@@ -153,7 +153,8 @@ public class DownloaderFragment extends BaseMwmRecyclerFragment<DownloaderAdapte
 
     mBottomPanel = new BottomPanel(this, view);
     mToolbarController = new DownloaderToolbarController(view, requireActivity(), this);
-    requireActivity().getOnBackPressedDispatcher().addCallback(getViewLifecycleOwner(), mToolbarController.getBackPressedCallback());
+    requireActivity().getOnBackPressedDispatcher().addCallback(getViewLifecycleOwner(),
+                                                               mToolbarController.getBackPressedCallback());
 
     update();
   }
@@ -195,7 +196,8 @@ public class DownloaderFragment extends BaseMwmRecyclerFragment<DownloaderAdapte
   {
     if (mAdapter == null)
       mAdapter = new DownloaderAdapter(this);
-    requireActivity().getOnBackPressedDispatcher().addCallback(getViewLifecycleOwner(), mAdapter.getBackPressedCallback());
+    requireActivity().getOnBackPressedDispatcher().addCallback(getViewLifecycleOwner(),
+                                                               mAdapter.getBackPressedCallback());
 
     return mAdapter;
   }

android/app/src/main/java/app/organicmaps/editor/EditorFragment.java

@@ -20,13 +20,13 @@ import androidx.recyclerview.widget.RecyclerView;
 import app.organicmaps.R;
 import app.organicmaps.base.BaseMwmFragment;
 import app.organicmaps.dialog.EditTextDialogFragment;
+import app.organicmaps.editor.data.TimeFormatUtils;
 import app.organicmaps.sdk.Framework;
 import app.organicmaps.sdk.bookmarks.data.Metadata;
 import app.organicmaps.sdk.editor.Editor;
 import app.organicmaps.sdk.editor.OpeningHours;
 import app.organicmaps.sdk.editor.data.LocalizedName;
 import app.organicmaps.sdk.editor.data.LocalizedStreet;
-import app.organicmaps.editor.data.TimeFormatUtils;
 import app.organicmaps.sdk.editor.data.Timetable;
 import app.organicmaps.sdk.util.StringUtils;
 import app.organicmaps.sdk.util.UiUtils;

android/app/src/main/java/app/organicmaps/editor/EditorHostFragment.java

@@ -292,8 +292,8 @@ public class EditorHostFragment
         editMapObject();
       }
       case STREET ->
-          setStreet(((StreetFragment) getChildFragmentManager().findFragmentByTag(StreetFragment.class.getName()))
+        setStreet(
-                        .getStreet());
+            ((StreetFragment) getChildFragmentManager().findFragmentByTag(StreetFragment.class.getName())).getStreet());
       case CUISINE ->
       {
         String[] cuisines =

android/app/src/main/java/app/organicmaps/editor/FeatureCategoryAdapter.java

@@ -7,13 +7,11 @@ import android.view.ViewGroup;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.recyclerview.widget.RecyclerView;
-
-import com.google.android.material.textfield.TextInputEditText;
-
 import app.organicmaps.R;
 import app.organicmaps.sdk.editor.data.FeatureCategory;
 import app.organicmaps.sdk.util.StringUtils;
 import app.organicmaps.sdk.util.UiUtils;
+import com.google.android.material.textfield.TextInputEditText;
 import com.google.android.material.textview.MaterialTextView;
 
 public class FeatureCategoryAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder>
@@ -67,7 +65,8 @@ public class FeatureCategoryAdapter extends RecyclerView.Adapter<RecyclerView.Vi
     case TYPE_FOOTER ->
     {
       return new FooterViewHolder(
-            LayoutInflater.from(parent.getContext()).inflate(R.layout.item_feature_category_footer, parent, false), (FooterListener) mFragment);
+          LayoutInflater.from(parent.getContext()).inflate(R.layout.item_feature_category_footer, parent, false),
+          (FooterListener) mFragment);
     }
     default -> throw new IllegalArgumentException("Unsupported");
     }

android/app/src/main/java/app/organicmaps/editor/FeatureCategoryFragment.java

@@ -1,34 +1,35 @@
 package app.organicmaps.editor;
 
 import static app.organicmaps.sdk.util.Utils.getLocalizedFeatureType;
+
+import android.content.Intent;
 import android.os.Bundle;
+import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.widget.Toast;
 import androidx.annotation.CallSuper;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import app.organicmaps.MwmApplication;
-import app.organicmaps.sdk.editor.Editor;
-import app.organicmaps.sdk.editor.data.FeatureCategory;
-import app.organicmaps.sdk.util.Language;
-import app.organicmaps.sdk.editor.OsmOAuth;
-import com.google.android.material.dialog.MaterialAlertDialogBuilder;
-import android.text.TextUtils;
-import android.content.Intent;
-import android.widget.Toast;
-
-import app.organicmaps.sdk.Framework;
 import app.organicmaps.R;
 import app.organicmaps.base.BaseMwmRecyclerFragment;
 import app.organicmaps.dialog.EditTextDialogFragment;
+import app.organicmaps.sdk.Framework;
+import app.organicmaps.sdk.editor.Editor;
+import app.organicmaps.sdk.editor.OsmOAuth;
+import app.organicmaps.sdk.editor.data.FeatureCategory;
+import app.organicmaps.sdk.util.Language;
 import app.organicmaps.util.Utils;
 import app.organicmaps.widget.SearchToolbarController;
 import app.organicmaps.widget.ToolbarController;
+import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class FeatureCategoryFragment extends BaseMwmRecyclerFragment<FeatureCategoryAdapter> implements FeatureCategoryAdapter.FooterListener
+public class FeatureCategoryFragment
+    extends BaseMwmRecyclerFragment<FeatureCategoryAdapter> implements FeatureCategoryAdapter.FooterListener
 {
   private FeatureCategory mSelectedCategory;
   protected ToolbarController mToolbarController;
@@ -58,8 +59,7 @@ public class FeatureCategoryFragment extends BaseMwmRecyclerFragment<FeatureCate
       mSelectedCategory =
           Utils.getParcelable(args, FeatureCategoryActivity.EXTRA_FEATURE_CATEGORY, FeatureCategory.class);
     }
-    mToolbarController = new SearchToolbarController(view, requireActivity())
+    mToolbarController = new SearchToolbarController(view, requireActivity()) {
-    {
       @Override
       protected void onTextChanged(String query)
       {
@@ -159,10 +159,12 @@ public class FeatureCategoryFragment extends BaseMwmRecyclerFragment<FeatureCate
   {
     new MaterialAlertDialogBuilder(requireActivity(), R.style.MwmTheme_AlertDialog)
         .setTitle(R.string.editor_share_to_all_dialog_title)
-      .setMessage(getString(R.string.editor_share_to_all_dialog_message_1)
+        .setMessage(getString(R.string.editor_share_to_all_dialog_message_1) + " "
-        + " " + getString(R.string.editor_share_to_all_dialog_message_2))
+                    + getString(R.string.editor_share_to_all_dialog_message_2))
-      .setPositiveButton(android.R.string.ok, (dlg, which) -> {
+        .setPositiveButton(android.R.string.ok,
-        MwmApplication.prefs(requireContext().getApplicationContext()).edit()
+                           (dlg, which) -> {
+                             MwmApplication.prefs(requireContext().getApplicationContext())
+                                 .edit()
                                  .putBoolean(NOTE_CONFIRMATION_SHOWN, true)
                                  .apply();
                              Editor.nativeCreateStandaloneNote(lat, lon, noteText);

android/app/src/main/java/app/organicmaps/editor/SimpleTimetableAdapter.java

@@ -13,9 +13,9 @@ import androidx.appcompat.widget.SwitchCompat;
 import androidx.fragment.app.Fragment;
 import androidx.recyclerview.widget.RecyclerView;
 import app.organicmaps.R;
+import app.organicmaps.editor.data.TimeFormatUtils;
 import app.organicmaps.sdk.editor.OpeningHours;
 import app.organicmaps.sdk.editor.data.HoursMinutes;
-import app.organicmaps.editor.data.TimeFormatUtils;
 import app.organicmaps.sdk.editor.data.Timespan;
 import app.organicmaps.sdk.editor.data.Timetable;
 import app.organicmaps.sdk.util.UiUtils;

android/app/src/main/java/app/organicmaps/routing/ManageRouteAdapter.java

@@ -11,14 +11,14 @@ import android.view.ViewGroup;
 import androidx.annotation.NonNull;
 import androidx.appcompat.content.res.AppCompatResources;
 import androidx.recyclerview.widget.RecyclerView;
-import com.google.android.material.imageview.ShapeableImageView;
-import com.google.android.material.textview.MaterialTextView;
 import app.organicmaps.R;
 import app.organicmaps.sdk.bookmarks.data.MapObject;
 import app.organicmaps.sdk.routing.RouteMarkData;
 import app.organicmaps.sdk.routing.RouteMarkType;
 import app.organicmaps.sdk.util.StringUtils;
 import app.organicmaps.sdk.util.UiUtils;
+import com.google.android.material.imageview.ShapeableImageView;
+import com.google.android.material.textview.MaterialTextView;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;

android/app/src/main/java/app/organicmaps/routing/RoutingBottomMenuController.java

@@ -119,10 +119,11 @@ final class RoutingBottomMenuController implements View.OnClickListener
 
   private RoutingBottomMenuController(@NonNull Activity context, @NonNull View altitudeChartFrame,
                                       @NonNull View timeElevationLine, @NonNull View transitFrame,
-                                      @NonNull MaterialTextView error, @NonNull Button start, @NonNull ImageView altitudeChart,
+                                      @NonNull MaterialTextView error, @NonNull Button start,
-                                      @NonNull MaterialTextView time, @NonNull MaterialTextView altitudeDifference,
+                                      @NonNull ImageView altitudeChart, @NonNull MaterialTextView time,
-                                      @NonNull TextView timeVehicle, @Nullable MaterialTextView arrival,
+                                      @NonNull MaterialTextView altitudeDifference, @NonNull TextView timeVehicle,
-                                      @NonNull View actionFrame, @Nullable RoutingBottomMenuListener listener)
+                                      @Nullable MaterialTextView arrival, @NonNull View actionFrame,
+                                      @Nullable RoutingBottomMenuListener listener)
   {
     mContext = context;
     mAltitudeChartFrame = altitudeChartFrame;

android/app/src/main/java/app/organicmaps/routing/RoutingErrorDialogFragment.java

@@ -13,11 +13,11 @@ import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
 import androidx.fragment.app.FragmentFactory;
 import androidx.fragment.app.FragmentManager;
-import com.google.android.material.textview.MaterialTextView;
 import app.organicmaps.R;
 import app.organicmaps.sdk.downloader.CountryItem;
 import app.organicmaps.sdk.downloader.MapManager;
 import app.organicmaps.sdk.util.UiUtils;
+import com.google.android.material.textview.MaterialTextView;
 
 public class RoutingErrorDialogFragment extends BaseRoutingErrorDialogFragment
 {

android/app/src/main/java/app/organicmaps/settings/VoiceInstructionsSettingsFragment.java

@@ -326,9 +326,9 @@ public class VoiceInstructionsSettingsFragment extends BaseXmlSettingsFragment
     final String ttsLinkText = getString(R.string.prefs_languages_information_off_link);
     final Spannable link = new SpannableString(ttsLinkText + "↗");
     // Set link color.
-    link.setSpan(
+    link.setSpan(new ForegroundColorSpan(ContextCompat.getColor(
-        new ForegroundColorSpan(ContextCompat.getColor(
+                     requireContext(),
-            requireContext(), UiUtils.getStyledResourceId(requireContext(), com.google.android.material.R.attr.colorSecondary))),
+                     UiUtils.getStyledResourceId(requireContext(), com.google.android.material.R.attr.colorSecondary))),
                  0, ttsLinkText.length(), 0);
     ttsLangInfoLink.setSummary(link);
 

android/app/src/main/java/app/organicmaps/widget/menu/NavMenu.java

@@ -166,8 +166,8 @@ public class NavMenu
 
   public void refreshTts()
   {
-    mTts.setImageDrawable(TtsPlayer.isEnabled()
+    mTts.setImageDrawable(TtsPlayer.isEnabled() ? Graphics.tint(mActivity, R.drawable.ic_voice_on,
-                              ? Graphics.tint(mActivity, R.drawable.ic_voice_on, com.google.android.material.R.attr.colorSecondary)
+                                                                com.google.android.material.R.attr.colorSecondary)
                                                 : Graphics.tint(mActivity, R.drawable.ic_voice_off));
   }
 

android/app/src/main/java/app/organicmaps/widget/placepage/PlacePageView.java

@@ -478,7 +478,8 @@ public class PlacePageView extends Fragment
       MaterialTextView mTvAddPlace = mAddPlace.findViewById(R.id.tv__editor);
       final int editPlaceButtonColor =
           Editor.nativeShouldEnableEditPlace()
-              ? ContextCompat.getColor(getContext(),
+              ? ContextCompat.getColor(
+                    getContext(),
                     UiUtils.getStyledResourceId(getContext(), com.google.android.material.R.attr.colorSecondary))
               : getResources().getColor(R.color.button_accent_text_disabled);
       mTvEditPlace.setTextColor(editPlaceButtonColor);

android/sdk/src/main/cpp/app/organicmaps/sdk/DownloadResourcesLegacyActivity.cpp

@@ -52,26 +52,23 @@ static std::shared_ptr<HttpRequest> g_currentRequest;
 
 extern "C"
 {
-  using Callback = HttpRequest::Callback;
+using Callback = HttpRequest::Callback;
 
-  static int HasSpaceForFiles(Platform & pl, std::string const & sdcardPath, size_t fileSize)
+static int HasSpaceForFiles(Platform & pl, std::string const & sdcardPath, size_t fileSize)
-  {
+{
   switch (pl.GetWritableStorageStatus(fileSize))
   {
-      case Platform::STORAGE_DISCONNECTED:
+  case Platform::STORAGE_DISCONNECTED: return ERR_STORAGE_DISCONNECTED;
-        return ERR_STORAGE_DISCONNECTED;
 
-      case Platform::NOT_ENOUGH_SPACE:
+  case Platform::NOT_ENOUGH_SPACE: return ERR_NOT_ENOUGH_FREE_SPACE;
-        return ERR_NOT_ENOUGH_FREE_SPACE;
 
-      default:
+  default: return static_cast<int>(fileSize);
-        return static_cast<int>(fileSize);
-    }
   }
+}
 
-  JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_DownloadResourcesLegacyActivity_nativeGetBytesToDownload(JNIEnv * env,
-  Java_app_organicmaps_sdk_DownloadResourcesLegacyActivity_nativeGetBytesToDownload(JNIEnv * env, jclass clazz)
+                                                                                                         jclass clazz)
-  {
+{
   // clear all
   g_filesToDownload.clear();
   g_totalBytesToDownload = 0;
@@ -85,8 +82,7 @@ extern "C"
     g_totalBytesToDownload += cf.GetRemoteSize();
 
   int res;
-    if (status == Storage::WorldStatus::ERROR_CREATE_FOLDER ||
+  if (status == Storage::WorldStatus::ERROR_CREATE_FOLDER || status == Storage::WorldStatus::ERROR_MOVE_FILE)
-        status == Storage::WorldStatus::ERROR_MOVE_FILE)
   {
     res = ERR_DISK_ERROR;
   }
@@ -110,10 +106,10 @@ extern "C"
   }
 
   return res;
-  }
+}
 
-  static void DownloadFileFinished(std::shared_ptr<jobject> obj, HttpRequest const & req)
+static void DownloadFileFinished(std::shared_ptr<jobject> obj, HttpRequest const & req)
-  {
+{
   auto const status = req.GetStatus();
   ASSERT_NOT_EQUAL(status, DownloadStatus::InProgress, ());
 
@@ -139,18 +135,19 @@ extern "C"
 
   jmethodID methodID = jni::GetMethodID(env, *obj, "onFinish", "(I)V");
   env->CallVoidMethod(*obj, methodID, errorCode);
-  }
+}
 
-  static void DownloadFileProgress(std::shared_ptr<jobject> listener, HttpRequest const & req)
+static void DownloadFileProgress(std::shared_ptr<jobject> listener, HttpRequest const & req)
-  {
+{
   JNIEnv * env = jni::GetEnv();
   static jmethodID methodID = jni::GetMethodID(env, *listener, "onProgress", "(I)V");
-    env->CallVoidMethod(*listener, methodID, static_cast<jint>(g_totalDownloadedBytes + req.GetProgress().m_bytesDownloaded));
+  env->CallVoidMethod(*listener, methodID,
-  }
+                      static_cast<jint>(g_totalDownloadedBytes + req.GetProgress().m_bytesDownloaded));
+}
 
-  JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_DownloadResourcesLegacyActivity_nativeStartNextFileDownload(
-  Java_app_organicmaps_sdk_DownloadResourcesLegacyActivity_nativeStartNextFileDownload(JNIEnv * env, jclass clazz, jobject listener)
+    JNIEnv * env, jclass clazz, jobject listener)
-  {
+{
   if (g_filesToDownload.empty())
     return ERR_NO_MORE_FILES;
 
@@ -165,22 +162,19 @@ extern "C"
     auto const fileName = curFile.GetFileName(MapFileType::Map);
     LOG(LINFO, ("Downloading file", fileName));
 
-      g_currentRequest.reset(HttpRequest::GetFile(
+    g_currentRequest.reset(HttpRequest::GetFile(downloader->MakeUrlListLegacy(fileName),
-          downloader->MakeUrlListLegacy(fileName),
                                                 storage.GetFilePath(curFile.GetName(), MapFileType::Map),
-          curFile.GetRemoteSize(),
+                                                curFile.GetRemoteSize(), std::bind(&DownloadFileFinished, ptr, _1),
-          std::bind(&DownloadFileFinished, ptr, _1),
+                                                std::bind(&DownloadFileProgress, ptr, _1), 0, false));
-          std::bind(&DownloadFileProgress, ptr, _1),
-          0, false));
   });
 
   return ERR_FILE_IN_PROGRESS;
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_DownloadResourcesLegacyActivity_nativeCancelCurrentFile(JNIEnv * env,
-  Java_app_organicmaps_sdk_DownloadResourcesLegacyActivity_nativeCancelCurrentFile(JNIEnv * env, jclass clazz)
+                                                                                                        jclass clazz)
-  {
+{
   LOG(LDEBUG, ("cancelCurrentFile, currentRequest=", g_currentRequest));
   g_currentRequest.reset();
-  }
+}
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/Framework.hpp

@@ -10,9 +10,8 @@
 
 #include "drape_frontend/gui/skin.hpp"
 
-#include "drape/pointers.hpp"
 #include "drape/graphics_context_factory.hpp"
-
+#include "drape/pointers.hpp"
 
 #include "indexer/feature_decl.hpp"
 #include "indexer/map_style.hpp"
@@ -39,27 +38,27 @@ struct EverywhereSearchParams;
 
 namespace android
 {
-  enum CoordinatesFormat // See Java enum app.organicmaps.widget.placepage.CoordinatesFormat for all possible values.
+enum CoordinatesFormat  // See Java enum app.organicmaps.widget.placepage.CoordinatesFormat for all possible values.
-  {
+{
   LatLonDMS = 0,      // Latitude, Longitude in degrees minutes seconds format, comma separated
   LatLonDecimal = 1,  // Latitude, Longitude in decimal format, comma separated
   OLCFull = 2,        // Open location code, full format
   OSMLink = 3,        // Link to the OSM. E.g. https://osm.org/go/xcXjyqQlq-?m=
   UTM = 4,            // Universal Transverse Mercator
   MGRS = 5            // Military Grid Reference System
-  };
+};
 
-  // Keep in sync `public @interface ChoosePositionMode`in Framework.java.
+// Keep in sync `public @interface ChoosePositionMode`in Framework.java.
-  enum class ChoosePositionMode
+enum class ChoosePositionMode
-  {
+{
   None = 0,
   Editor = 1,
   Api = 2,
-  };
+};
 
-  class Framework : private power_management::PowerManager::Subscriber
+class Framework : private power_management::PowerManager::Subscriber
-  {
+{
-  private:
+private:
   drape_ptr<dp::ThreadSafeFactory> m_oglContextFactory;
   drape_ptr<dp::GraphicsContextFactory> m_vulkanContextFactory;
   ::Framework m_work;
@@ -86,7 +85,7 @@ namespace android
   ChoosePositionMode m_isChoosePositionMode = ChoosePositionMode::None;
   bool m_isSurfaceDestroyed = false;
 
-  public:
+public:
   Framework(std::function<void()> && afterMapsLoaded);
 
   storage::Storage & GetStorage();
@@ -94,12 +93,12 @@ namespace android
 
   void ShowNode(storage::CountryId const & countryId, bool zoomToDownloadButton);
 
-    void OnLocationError(int/* == location::TLocationStatus*/ newStatus);
+  void OnLocationError(int /* == location::TLocationStatus*/ newStatus);
   void OnLocationUpdated(location::GpsInfo const & info);
   void OnCompassUpdated(location::CompassInfo const & info, bool forceRedraw);
 
-    bool CreateDrapeEngine(JNIEnv * env, jobject jSurface, int densityDpi, bool firstLaunch,
+  bool CreateDrapeEngine(JNIEnv * env, jobject jSurface, int densityDpi, bool firstLaunch, bool launchByDeepLink,
-                           bool launchByDeepLink, uint32_t appVersionCode, bool isCustomROM);
+                         uint32_t appVersionCode, bool isCustomROM);
   bool IsDrapeEngineCreated() const;
   void UpdateDpi(int dpi);
   bool DestroySurfaceOnDetach();
@@ -117,21 +116,13 @@ namespace android
   RoutingManager & GetRoutingManager() { return m_work.GetRoutingManager(); }
   void SetRouter(routing::RouterType type) { m_work.GetRoutingManager().SetRouter(type); }
   routing::RouterType GetRouter() const { return m_work.GetRoutingManager().GetRouter(); }
-    routing::RouterType GetLastUsedRouter() const
+  routing::RouterType GetLastUsedRouter() const { return m_work.GetRoutingManager().GetLastUsedRouter(); }
-    {
-      return m_work.GetRoutingManager().GetLastUsedRouter();
-    }
 
   void Resize(JNIEnv * env, jobject jSurface, int w, int h);
 
   struct Finger
   {
-      Finger(int64_t id, float x, float y)
+    Finger(int64_t id, float x, float y) : m_id(id), m_x(x), m_y(y) {}
-        : m_id(id)
-        , m_x(x)
-        , m_y(y)
-      {
-      }
 
     int64_t m_id;
     float m_x, m_y;
@@ -173,7 +164,7 @@ namespace android
   void DeactivatePopup();
   void DeactivateMapSelectionCircle(bool restoreViewport);
 
-//    std::string GetOutdatedCountriesString();
+  //    std::string GetOutdatedCountriesString();
 
   void SetMyPositionModeListener(location::TMyPositionModeChanged const & fn);
   location::EMyPositionMode GetMyPositionMode() const;
@@ -208,15 +199,15 @@ namespace android
   bool IsDownloadOn3gEnabled();
   void EnableDownloadOn3g();
 
-//    int ToDoAfterUpdate() const;
+  //    int ToDoAfterUpdate() const;
 
   // PowerManager::Subscriber overrides:
   void OnPowerFacilityChanged(power_management::Facility const facility, bool enabled) override;
   void OnPowerSchemeChanged(power_management::Scheme const actualScheme) override;
 
   FeatureID BuildFeatureId(JNIEnv * env, jobject featureId);
-  };
+};
-}
+}  // namespace android
 
 extern std::unique_ptr<android::Framework> g_framework;
 ::Framework * frm();

android/sdk/src/main/cpp/app/organicmaps/sdk/LocationState.cpp

@@ -7,26 +7,23 @@
 
 extern "C"
 {
-
+static void LocationStateModeChanged(location::EMyPositionMode mode, std::shared_ptr<jobject> const & listener)
-static void LocationStateModeChanged(location::EMyPositionMode mode,
-                                     std::shared_ptr<jobject> const & listener)
 {
   JNIEnv * env = jni::GetEnv();
-  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener.get(),
+  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener.get(), "onMyPositionModeChanged", "(I)V"),
-                      "onMyPositionModeChanged", "(I)V"), static_cast<jint>(mode));
+                      static_cast<jint>(mode));
 }
 
 //  public static void nativeSwitchToNextMode();
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_LocationState_nativeSwitchToNextMode(JNIEnv * env,
-Java_app_organicmaps_sdk_location_LocationState_nativeSwitchToNextMode(JNIEnv * env, jclass clazz)
+                                                                                              jclass clazz)
 {
   ASSERT(g_framework, ());
   g_framework->SwitchMyPositionNextMode();
 }
 
 // private static int nativeGetMode();
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_location_LocationState_nativeGetMode(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_location_LocationState_nativeGetMode(JNIEnv * env, jclass clazz)
 {
   // GetMyPositionMode() is initialized only after drape creation.
   // https://github.com/organicmaps/organicmaps/issues/1128#issuecomment-1784435190
@@ -35,34 +32,31 @@ Java_app_organicmaps_sdk_location_LocationState_nativeGetMode(JNIEnv * env, jcla
 }
 
 //  public static void nativeSetListener(ModeChangeListener listener);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_LocationState_nativeSetListener(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_location_LocationState_nativeSetListener(JNIEnv * env, jclass clazz,
                                                                                          jobject listener)
 {
   ASSERT(g_framework, ());
-  g_framework->SetMyPositionModeListener(std::bind(&LocationStateModeChanged, std::placeholders::_1,
+  g_framework->SetMyPositionModeListener(
-                                                   jni::make_global_ref(listener)));
+      std::bind(&LocationStateModeChanged, std::placeholders::_1, jni::make_global_ref(listener)));
 }
 
 //  public static void nativeRemoveListener();
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_LocationState_nativeRemoveListener(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_location_LocationState_nativeRemoveListener(JNIEnv * env, jclass clazz)
 {
   ASSERT(g_framework, ());
   g_framework->SetMyPositionModeListener(location::TMyPositionModeChanged());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_LocationState_nativeOnLocationError(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_location_LocationState_nativeOnLocationError(JNIEnv * env, jclass clazz, int errorCode)
+                                                                                             int errorCode)
 {
   ASSERT(g_framework, ());
   g_framework->OnLocationError(errorCode);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_LocationState_nativeLocationUpdated(
-Java_app_organicmaps_sdk_location_LocationState_nativeLocationUpdated(JNIEnv * env, jclass clazz, jlong time,
+    JNIEnv * env, jclass clazz, jlong time, jdouble lat, jdouble lon, jfloat accuracy, jdouble altitude, jfloat speed,
-                                                                  jdouble lat, jdouble lon, jfloat accuracy,
+    jfloat bearing)
-                                                                  jdouble altitude, jfloat speed, jfloat bearing)
 {
   ASSERT(g_framework, ());
   location::GpsInfo info;

android/sdk/src/main/cpp/app/organicmaps/sdk/Map.cpp

@@ -15,46 +15,38 @@ namespace
 void OnRenderingInitializationFinished(std::shared_ptr<jobject> const & listener)
 {
   JNIEnv * env = jni::GetEnv();
-  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener.get(),
+  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener.get(), "onRenderingInitializationFinished", "()V"));
-                      "onRenderingInitializationFinished", "()V"));
 }
 }  // namespace
 
 extern "C"
 {
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_Map_nativeCreateEngine(JNIEnv * env, jclass, jobject surface,
-Java_app_organicmaps_sdk_Map_nativeCreateEngine(JNIEnv * env, jclass,
+                                                                           jint density, jboolean firstLaunch,
-                                            jobject surface, jint density,
-                                            jboolean firstLaunch,
                                                                            jboolean isLaunchByDeepLink,
-                                            jint appVersionCode,
+                                                                           jint appVersionCode, jboolean isCustomROM)
-                                            jboolean isCustomROM)
 {
   return g_framework->CreateDrapeEngine(env, surface, density, firstLaunch, isLaunchByDeepLink,
                                         base::asserted_cast<uint32_t>(appVersionCode), isCustomROM);
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_Map_nativeIsEngineCreated(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeIsEngineCreated(JNIEnv *, jclass)
 {
   return g_framework->IsDrapeEngineCreated();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeUpdateEngineDpi(JNIEnv *, jclass, jint dpi)
-Java_app_organicmaps_sdk_Map_nativeUpdateEngineDpi(JNIEnv *, jclass, jint dpi)
 {
   return g_framework->UpdateDpi(dpi);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeExecuteMapApiRequest(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_Map_nativeExecuteMapApiRequest(JNIEnv * env, jclass)
 {
   return g_framework->ExecuteMapApiRequest();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeSetRenderingInitializationFinishedListener(JNIEnv *, jclass,
-Java_app_organicmaps_sdk_Map_nativeSetRenderingInitializationFinishedListener(
+                                                                                                     jobject listener)
-  JNIEnv *, jclass, jobject listener)
 {
   if (listener)
   {
@@ -67,69 +59,61 @@ Java_app_organicmaps_sdk_Map_nativeSetRenderingInitializationFinishedListener(
   }
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_Map_nativeAttachSurface(JNIEnv * env, jclass, jobject surface)
-Java_app_organicmaps_sdk_Map_nativeAttachSurface(JNIEnv * env, jclass, jobject surface)
 {
   return g_framework->AttachSurface(env, surface);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeDetachSurface(JNIEnv *, jclass, jboolean destroySurface)
-Java_app_organicmaps_sdk_Map_nativeDetachSurface(JNIEnv *, jclass, jboolean destroySurface)
 {
   g_framework->DetachSurface(destroySurface);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeSurfaceChanged(JNIEnv * env, jclass, jobject surface, jint w,
-Java_app_organicmaps_sdk_Map_nativeSurfaceChanged(JNIEnv * env, jclass, jobject surface, jint w, jint h)
+                                                                         jint h)
 {
   g_framework->Resize(env, surface, w, h);
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_Map_nativeDestroySurfaceOnDetach(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeDestroySurfaceOnDetach(JNIEnv *, jclass)
 {
   return g_framework->DestroySurfaceOnDetach();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativePauseSurfaceRendering(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativePauseSurfaceRendering(JNIEnv *, jclass)
 {
   g_framework->PauseSurfaceRendering();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeResumeSurfaceRendering(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeResumeSurfaceRendering(JNIEnv *, jclass)
 {
   g_framework->ResumeSurfaceRendering();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeUpdateMyPositionRoutingOffset(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_Map_nativeUpdateMyPositionRoutingOffset(JNIEnv * env, jclass clazz, int offsetY)
+                                                                                        int offsetY)
 {
   g_framework->UpdateMyPositionRoutingOffset(offsetY);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeApplyWidgets(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeApplyWidgets(JNIEnv *, jclass)
 {
   g_framework->ApplyWidgets();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeCleanWidgets(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeCleanWidgets(JNIEnv *, jclass)
 {
   g_framework->CleanWidgets();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeSetupWidget(JNIEnv *, jclass, jint widget, jfloat x, jfloat y,
-Java_app_organicmaps_sdk_Map_nativeSetupWidget(
+                                                                      jint anchor)
-  JNIEnv *, jclass, jint widget, jfloat x, jfloat y, jint anchor)
 {
   g_framework->SetupWidget(static_cast<gui::EWidget>(widget), x, y, static_cast<dp::Anchor>(anchor));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeCompassUpdated(JNIEnv *, jclass, jdouble north,
-Java_app_organicmaps_sdk_Map_nativeCompassUpdated(JNIEnv *, jclass, jdouble north, jboolean forceRedraw)
+                                                                         jboolean forceRedraw)
 {
   location::CompassInfo info;
   info.m_bearing = north;
@@ -137,52 +121,43 @@ Java_app_organicmaps_sdk_Map_nativeCompassUpdated(JNIEnv *, jclass, jdouble nort
   g_framework->OnCompassUpdated(info, forceRedraw);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeScalePlus(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeScalePlus(JNIEnv *, jclass)
 {
   g_framework->Scale(::Framework::SCALE_MAG);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeScaleMinus(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeScaleMinus(JNIEnv *, jclass)
 {
   g_framework->Scale(::Framework::SCALE_MIN);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeOnScroll(JNIEnv *, jclass, jdouble distanceX,
-Java_app_organicmaps_sdk_Map_nativeOnScroll(
+                                                                   jdouble distanceY)
-  JNIEnv *, jclass, jdouble distanceX, jdouble distanceY)
 {
   g_framework->Scroll(distanceX, distanceY);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeOnScale(JNIEnv *, jclass, jdouble factor, jdouble focusX,
-Java_app_organicmaps_sdk_Map_nativeOnScale(
+                                                                  jdouble focusY, jboolean isAnim)
-  JNIEnv *, jclass, jdouble factor, jdouble focusX, jdouble focusY, jboolean isAnim)
 {
   g_framework->Scale(factor, {focusX, focusY}, isAnim);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeOnTouch(JNIEnv *, jclass, jint action, jint id1, jfloat x1,
-Java_app_organicmaps_sdk_Map_nativeOnTouch(JNIEnv *, jclass, jint action,
+                                                                  jfloat y1, jint id2, jfloat x2, jfloat y2,
-                                       jint id1, jfloat x1, jfloat y1,
-                                       jint id2, jfloat x2, jfloat y2,
                                                                   jint maskedPointer)
 {
-  g_framework->Touch(action,
+  g_framework->Touch(action, android::Framework::Finger(id1, x1, y1), android::Framework::Finger(id2, x2, y2),
-                     android::Framework::Finger(id1, x1, y1),
+                     maskedPointer);
-                     android::Framework::Finger(id2, x2, y2), maskedPointer);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeStorageConnected(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeStorageConnected(JNIEnv *, jclass)
 {
   android::Platform::Instance().OnExternalStorageStatusChanged(true);
   g_framework->AddLocalMaps();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_Map_nativeStorageDisconnected(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_Map_nativeStorageDisconnected(JNIEnv *, jclass)
 {
   android::Platform::Instance().OnExternalStorageStatusChanged(false);
   g_framework->RemoveLocalMaps();

android/sdk/src/main/cpp/app/organicmaps/sdk/MapManager.cpp

@@ -21,7 +21,6 @@
 #include <unordered_map>
 #include <vector>
 
-
 namespace
 {
 // The last 5% are left for applying diffs.
@@ -44,7 +43,10 @@ struct TBatchedData
 
   TBatchedData(storage::CountryId const & countryId, storage::NodeStatus const newStatus,
                storage::NodeErrorCode const errorCode, bool isLeaf)
-    : m_countryId(countryId), m_newStatus(newStatus), m_errorCode(errorCode), m_isLeaf(isLeaf)
+    : m_countryId(countryId)
+    , m_newStatus(newStatus)
+    , m_errorCode(errorCode)
+    , m_isLeaf(isLeaf)
   {}
 };
 
@@ -64,11 +66,11 @@ struct CountryItemBuilder
 {
   jclass m_class;
   jmethodID m_ctor;
-  jfieldID m_Id, m_Name, m_DirectParentId, m_TopmostParentId, m_DirectParentName, m_TopmostParentName,
+  jfieldID m_Id, m_Name, m_DirectParentId, m_TopmostParentId, m_DirectParentName, m_TopmostParentName, m_Description,
-          m_Description, m_Size, m_EnqueuedSize, m_TotalSize, m_ChildCount, m_TotalChildCount,
+      m_Size, m_EnqueuedSize, m_TotalSize, m_ChildCount, m_TotalChildCount, m_Present, m_Progress, m_DownloadedBytes,
-          m_Present, m_Progress, m_DownloadedBytes, m_BytesToDownload, m_Category, m_Status, m_ErrorCode;
+      m_BytesToDownload, m_Category, m_Status, m_ErrorCode;
 
-  CountryItemBuilder(JNIEnv *env)
+  CountryItemBuilder(JNIEnv * env)
   {
     m_class = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/downloader/CountryItem");
     m_ctor = jni::GetConstructorID(env, m_class, "(Ljava/lang/String;)V");
@@ -95,10 +97,7 @@ struct CountryItemBuilder
   }
 
   DECLARE_BUILDER_INSTANCE(CountryItemBuilder);
-  jobject Create(JNIEnv * env, jobject id) const
+  jobject Create(JNIEnv * env, jobject id) const { return env->NewObject(m_class, m_ctor, id); }
-  {
-    return env->NewObject(m_class, m_ctor, id);
-  }
 };
 
 static storage::CountryId const GetRootId(JNIEnv * env, jstring root)
@@ -109,52 +108,54 @@ static storage::CountryId const GetRootId(JNIEnv * env, jstring root)
 
 extern "C"
 {
-
 // static String nativeGetRoot();
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetRoot(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetRoot(JNIEnv * env, jclass clazz)
 {
   return jni::ToJavaString(env, GetStorage().GetRootId());
 }
 
 // static boolean nativeMoveFile(String oldFile, String newFile);
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeMoveFile(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeMoveFile(JNIEnv * env, jclass clazz, jstring oldFile, jstring newFile)
+                                                                                         jstring oldFile,
+                                                                                         jstring newFile)
 {
   return base::MoveFileX(jni::ToNativeString(env, oldFile), jni::ToNativeString(env, newFile));
 }
 
 // static boolean nativeHasSpaceToDownloadAmount(long bytes);
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeHasSpaceToDownloadAmount(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeHasSpaceToDownloadAmount(JNIEnv * env, jclass clazz, jlong bytes)
+                                                                                                         jclass clazz,
+                                                                                                         jlong bytes)
 {
   return storage::IsEnoughSpaceForDownload(bytes);
 }
 
 // static boolean nativeHasSpaceToDownloadCountry(String root);
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeHasSpaceToDownloadCountry(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeHasSpaceToDownloadCountry(JNIEnv * env, jclass clazz, jstring root)
+                                                                                                          jclass clazz,
+                                                                                                          jstring root)
 {
   return storage::IsEnoughSpaceForDownload(jni::ToNativeString(env, root), GetStorage());
 }
 
 // static boolean nativeHasSpaceToUpdate(String root);
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeHasSpaceToUpdate(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeHasSpaceToUpdate(JNIEnv * env, jclass clazz, jstring root)
+                                                                                                 jclass clazz,
+                                                                                                 jstring root)
 {
   return IsEnoughSpaceForUpdate(jni::ToNativeString(env, root), GetStorage());
 }
 
 // static int nativeGetDownloadedCount();
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetDownloadedCount(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetDownloadedCount(JNIEnv * env, jclass clazz)
+                                                                                               jclass clazz)
 {
   return static_cast<jint>(GetStorage().GetDownloadedFilesCount());
 }
 
 // static @Nullable UpdateInfo nativeGetUpdateInfo(@Nullable String root);
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetUpdateInfo(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetUpdateInfo(JNIEnv * env, jclass clazz, jstring root)
+                                                                                             jstring root)
 {
   storage::Storage::UpdateInfo info;
   if (!GetStorage().GetUpdateInfo(GetRootId(env, root), info))
@@ -168,7 +169,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeGetUpdateInfo(JNIEnv * env,
   return env->NewObject(infoClass, ctor, info.m_numberOfMwmFilesToUpdate, info.m_totalDownloadSizeInBytes);
 }
 
-static void UpdateItemShort(JNIEnv * env, jobject item, storage::NodeStatus const status, storage::NodeErrorCode const error)
+static void UpdateItemShort(JNIEnv * env, jobject item, storage::NodeStatus const status,
+                            storage::NodeErrorCode const error)
 {
   auto const & ciBuilder = CountryItemBuilder::Instance(env);
 
@@ -211,7 +213,8 @@ static void UpdateItem(JNIEnv * env, jobject item, storage::NodeAttrs const & at
   }
 
   // Description
-  env->SetObjectField(item, ciBuilder.m_Description, SLR(env, jni::ToJavaString(env, attrs.m_nodeLocalDescription)).get());
+  env->SetObjectField(item, ciBuilder.m_Description,
+                      SLR(env, jni::ToJavaString(env, attrs.m_nodeLocalDescription)).get());
 
   // Sizes
   env->SetLongField(item, ciBuilder.m_Size, attrs.m_localMwmSize);
@@ -267,18 +270,21 @@ static void PutItemsToList(
   }
 }
 
-// static void nativeListItems(@Nullable String root, double lat, double lon, boolean hasLocation, boolean myMapsMode, List<CountryItem> result);
+// static void nativeListItems(@Nullable String root, double lat, double lon, boolean hasLocation, boolean myMapsMode,
-JNIEXPORT void JNICALL
+// List<CountryItem> result);
-Java_app_organicmaps_sdk_downloader_MapManager_nativeListItems(JNIEnv * env, jclass clazz, jstring parent, jdouble lat, jdouble lon, jboolean hasLocation, jboolean myMapsMode, jobject result)
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeListItems(JNIEnv * env, jclass clazz,
+                                                                                      jstring parent, jdouble lat,
+                                                                                      jdouble lon, jboolean hasLocation,
+                                                                                      jboolean myMapsMode,
+                                                                                      jobject result)
 {
   if (hasLocation && !myMapsMode)
   {
     storage::CountriesVec near;
     g_framework->NativeFramework()->GetCountryInfoGetter().GetRegionsCountryId(mercator::FromLatLon(lat, lon), near);
     PutItemsToList(env, result, near, ItemCategory::NEAR_ME,
-                   [](storage::CountryId const & countryId, storage::NodeAttrs const & attrs) -> bool {
+                   [](storage::CountryId const & countryId, storage::NodeAttrs const & attrs) -> bool
-                     return !attrs.m_present;
+    { return !attrs.m_present; });
-                   });
   }
 
   storage::CountriesVec downloaded, available;
@@ -291,8 +297,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeListItems(JNIEnv * env, jcl
 }
 
 // static void nativeUpdateItem(CountryItem item);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetAttributes(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetAttributes(JNIEnv * env, jclass, jobject item)
+                                                                                          jobject item)
 {
   auto const & ciBuilder = CountryItemBuilder::Instance(env);
   jstring id = static_cast<jstring>(env->GetObjectField(item, ciBuilder.m_Id));
@@ -304,8 +310,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeGetAttributes(JNIEnv * env,
 }
 
 // static void nativeGetStatus(String root);
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetStatus(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetStatus(JNIEnv * env, jclass clazz, jstring root)
+                                                                                      jstring root)
 {
   storage::NodeStatuses ns;
   GetStorage().GetNodeStatuses(jni::ToNativeString(env, root), ns);
@@ -313,8 +319,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeGetStatus(JNIEnv * env, jcl
 }
 
 // static void nativeGetError(String root);
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetError(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetError(JNIEnv * env, jclass clazz, jstring root)
+                                                                                     jstring root)
 {
   storage::NodeStatuses ns;
   GetStorage().GetNodeStatuses(jni::ToNativeString(env, root), ns);
@@ -322,22 +328,23 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeGetError(JNIEnv * env, jcla
 }
 
 // static String nativeGetName(String root);
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetName(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetName(JNIEnv * env, jclass clazz, jstring root)
+                                                                                       jstring root)
 {
   return jni::ToJavaString(env, GetStorage().GetNodeLocalName(jni::ToNativeString(env, root)));
 }
 
 // static @Nullable String nativeFindCountry(double lat, double lon);
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeFindCountry(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeFindCountry(JNIEnv * env, jclass clazz, jdouble lat, jdouble lon)
+                                                                                           jdouble lat, jdouble lon)
 {
-  return jni::ToJavaString(env, g_framework->NativeFramework()->GetCountryInfoGetter().GetRegionCountryId(mercator::FromLatLon(lat, lon)));
+  return jni::ToJavaString(
+      env, g_framework->NativeFramework()->GetCountryInfoGetter().GetRegionCountryId(mercator::FromLatLon(lat, lon)));
 }
 
 // static boolean nativeIsDownloading();
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeIsDownloading(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeIsDownloading(JNIEnv * env, jclass clazz)
+                                                                                              jclass clazz)
 {
   return static_cast<jboolean>(GetStorage().IsDownloadInProgress());
 }
@@ -365,14 +372,14 @@ static void EndBatchingCallbacks(JNIEnv * env)
     for (TBatchedData const & dataItem : key.second)
     {
       // Create StorageCallbackData instance…
-      static jclass batchDataClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/downloader/MapManager$StorageCallbackData");
+      static jclass batchDataClass =
+          jni::GetGlobalClassRef(env, "app/organicmaps/sdk/downloader/MapManager$StorageCallbackData");
       static jmethodID batchDataCtor = jni::GetConstructorID(env, batchDataClass, "(Ljava/lang/String;IIZ)V");
 
       jni::TScopedLocalRef const id(env, jni::ToJavaString(env, dataItem.m_countryId));
-      jni::TScopedLocalRef const item(env, env->NewObject(batchDataClass, batchDataCtor, id.get(),
+      jni::TScopedLocalRef const item(
-                                                                                         static_cast<jint>(dataItem.m_newStatus),
+          env, env->NewObject(batchDataClass, batchDataCtor, id.get(), static_cast<jint>(dataItem.m_newStatus),
-                                                                                         static_cast<jint>(dataItem.m_errorCode),
+                              static_cast<jint>(dataItem.m_errorCode), dataItem.m_isLeaf));
-                                                                                         dataItem.m_isLeaf));
       // …and put it into the resulting list
       env->CallBooleanMethod(list.get(), listBuilder.m_add, item.get());
     }
@@ -387,8 +394,8 @@ static void EndBatchingCallbacks(JNIEnv * env)
 }
 
 // static void nativeDownload(String root);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeDownload(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeDownload(JNIEnv * env, jclass clazz, jstring root)
+                                                                                     jstring root)
 {
   StartBatchingCallbacks();
   GetStorage().DownloadNode(jni::ToNativeString(env, root));
@@ -396,8 +403,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeDownload(JNIEnv * env, jcla
 }
 
 // static boolean nativeRetry(String root);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeRetry(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeRetry(JNIEnv * env, jclass clazz, jstring root)
+                                                                                  jstring root)
 {
   StartBatchingCallbacks();
   GetStorage().RetryDownloadNode(jni::ToNativeString(env, root));
@@ -405,8 +412,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeRetry(JNIEnv * env, jclass
 }
 
 // static void nativeUpdate(String root);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeUpdate(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeUpdate(JNIEnv * env, jclass clazz, jstring root)
+                                                                                   jstring root)
 {
   StartBatchingCallbacks();
   GetStorage().UpdateNode(GetRootId(env, root));
@@ -414,8 +421,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeUpdate(JNIEnv * env, jclass
 }
 
 // static void nativeCancel(String root);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeCancel(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeCancel(JNIEnv * env, jclass clazz, jstring root)
+                                                                                   jstring root)
 {
   StartBatchingCallbacks();
   GetStorage().CancelDownloadNode(GetRootId(env, root));
@@ -423,8 +430,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeCancel(JNIEnv * env, jclass
 }
 
 // static void nativeDelete(String root);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeDelete(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeDelete(JNIEnv * env, jclass clazz, jstring root)
+                                                                                   jstring root)
 {
   StartBatchingCallbacks();
   auto const countryId = jni::ToNativeString(env, root);
@@ -432,8 +439,7 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeDelete(JNIEnv * env, jclass
   EndBatchingCallbacks(env);
 }
 
-static void StatusChangedCallback(std::shared_ptr<jobject> const & listenerRef,
+static void StatusChangedCallback(std::shared_ptr<jobject> const & listenerRef, storage::CountryId const & countryId)
-                                  storage::CountryId const & countryId)
 {
   storage::NodeStatuses ns;
   GetStorage().GetNodeStatuses(countryId, ns);
@@ -445,42 +451,48 @@ static void StatusChangedCallback(std::shared_ptr<jobject> const & listenerRef,
     EndBatchingCallbacks(jni::GetEnv());
 }
 
-static void ProgressChangedCallback(std::shared_ptr<jobject> const & listenerRef,
+static void ProgressChangedCallback(std::shared_ptr<jobject> const & listenerRef, storage::CountryId const & countryId,
-                                    storage::CountryId const & countryId, downloader::Progress const & progress)
+                                    downloader::Progress const & progress)
 {
   JNIEnv * env = jni::GetEnv();
 
   jmethodID const methodID = jni::GetMethodID(env, *listenerRef, "onProgress", "(Ljava/lang/String;JJ)V");
-  env->CallVoidMethod(*listenerRef, methodID, jni::ToJavaString(env, countryId),
+  env->CallVoidMethod(*listenerRef, methodID, jni::ToJavaString(env, countryId), progress.m_bytesDownloaded,
-                      progress.m_bytesDownloaded, progress.m_bytesTotal);
+                      progress.m_bytesTotal);
 }
 
 // static int nativeSubscribe(StorageCallback listener);
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeSubscribe(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeSubscribe(JNIEnv * env, jclass clazz, jobject listener)
+                                                                                      jobject listener)
 {
-  return GetStorage().Subscribe(std::bind(&StatusChangedCallback, jni::make_global_ref(listener), std::placeholders::_1),
+  return GetStorage().Subscribe(
-                                std::bind(&ProgressChangedCallback, jni::make_global_ref(listener), std::placeholders::_1, std::placeholders::_2));
+      std::bind(&StatusChangedCallback, jni::make_global_ref(listener), std::placeholders::_1),
+      std::bind(&ProgressChangedCallback, jni::make_global_ref(listener), std::placeholders::_1,
+                std::placeholders::_2));
 }
 
 // static void nativeUnsubscribe(int slot);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeUnsubscribe(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeUnsubscribe(JNIEnv * env, jclass clazz, jint slot)
+                                                                                        jint slot)
 {
   GetStorage().Unsubscribe(slot);
 }
 
 // static void nativeSubscribeOnCountryChanged(CurrentCountryChangedListener listener);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeSubscribeOnCountryChanged(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeSubscribeOnCountryChanged(JNIEnv * env, jclass clazz, jobject listener)
+                                                                                                      jclass clazz,
+                                                                                                      jobject listener)
 {
   ASSERT(!g_countryChangedListener, ());
   g_countryChangedListener = env->NewGlobalRef(listener);
 
-  auto const callback = [](storage::CountryId const & countryId) {
+  auto const callback = [](storage::CountryId const & countryId)
+  {
     JNIEnv * env = jni::GetEnv();
-    jmethodID methodID = jni::GetMethodID(env, g_countryChangedListener, "onCurrentCountryChanged", "(Ljava/lang/String;)V");
+    jmethodID methodID =
-    env->CallVoidMethod(g_countryChangedListener, methodID, jni::TScopedLocalRef(env, jni::ToJavaString(env, countryId)).get());
+        jni::GetMethodID(env, g_countryChangedListener, "onCurrentCountryChanged", "(Ljava/lang/String;)V");
+    env->CallVoidMethod(g_countryChangedListener, methodID,
+                        jni::TScopedLocalRef(env, jni::ToJavaString(env, countryId)).get());
   };
 
   storage::CountryId const & prev = g_framework->NativeFramework()->GetLastReportedCountry();
@@ -491,8 +503,8 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeSubscribeOnCountryChanged(J
 }
 
 // static void nativeUnsubscribeOnCountryChanged();
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeUnsubscribeOnCountryChanged(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeUnsubscribeOnCountryChanged(JNIEnv * env, jclass clazz)
+                                                                                                        jclass clazz)
 {
   g_framework->NativeFramework()->SetCurrentCountryChangedListener(nullptr);
 
@@ -501,15 +513,16 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeUnsubscribeOnCountryChanged
 }
 
 // static boolean nativeHasUnsavedEditorChanges(String root);
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeHasUnsavedEditorChanges(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeHasUnsavedEditorChanges(JNIEnv * env, jclass clazz, jstring root)
+                                                                                                        jclass clazz,
+                                                                                                        jstring root)
 {
   return g_framework->NativeFramework()->HasUnsavedEdits(jni::ToNativeString(env, root));
 }
 
 // static void nativeGetPathTo(String root, List<String> result);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetPathTo(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetPathTo(JNIEnv * env, jclass clazz, jstring root, jobject result)
+                                                                                      jstring root, jobject result)
 {
   auto const listAddMethod = jni::ListBuilder::Instance(env).m_add;
 
@@ -520,8 +533,9 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeGetPathTo(JNIEnv * env, jcl
 }
 
 // static int nativeGetOverallProgress(String[] countries);
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetOverallProgress(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetOverallProgress(JNIEnv * env, jclass clazz, jobjectArray jcountries)
+                                                                                               jclass clazz,
+                                                                                               jobjectArray jcountries)
 {
   int const size = env->GetArrayLength(jcountries);
   storage::CountriesVec countries;
@@ -543,29 +557,29 @@ Java_app_organicmaps_sdk_downloader_MapManager_nativeGetOverallProgress(JNIEnv *
 }
 
 // static boolean nativeIsAutoretryFailed();
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeIsAutoretryFailed(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeIsAutoretryFailed(JNIEnv * env, jclass clazz)
+                                                                                                  jclass clazz)
 {
   return g_framework->IsAutoRetryDownloadFailed();
 }
 
 // static boolean nativeIsDownloadOn3gEnabled();
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeIsDownloadOn3gEnabled(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeIsDownloadOn3gEnabled(JNIEnv * env, jclass clazz)
+                                                                                                      jclass clazz)
 {
   return g_framework->IsDownloadOn3gEnabled();
 }
 
 // static void nativeEnableDownloadOn3g();
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeEnableDownloadOn3g(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeEnableDownloadOn3g(JNIEnv * env, jclass clazz)
+                                                                                               jclass clazz)
 {
   g_framework->EnableDownloadOn3g();
 }
 
 // static @Nullable String nativeGetSelectedCountry();
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_downloader_MapManager_nativeGetSelectedCountry(JNIEnv * env,
-Java_app_organicmaps_sdk_downloader_MapManager_nativeGetSelectedCountry(JNIEnv * env, jclass clazz)
+                                                                                                  jclass clazz)
 {
   if (!g_framework->NativeFramework()->HasPlacePageInfo())
     return nullptr;

android/sdk/src/main/cpp/app/organicmaps/sdk/OrganicMaps.cpp

@@ -29,8 +29,7 @@ JNIEXPORT void JNICALL Java_app_organicmaps_sdk_OrganicMaps_nativeInitFramework(
 {
   if (!g_framework)
   {
-    g_framework = std::make_unique<android::Framework>(
+    g_framework = std::make_unique<android::Framework>([onComplete = jni::make_global_ref(onComplete)]()
-      [onComplete = jni::make_global_ref(onComplete)]()
     {
       JNIEnv * env = jni::GetEnv();
       jmethodID const methodId = jni::GetMethodID(env, *onComplete, "run", "()V");

android/sdk/src/main/cpp/app/organicmaps/sdk/TrackRecorder.cpp

@@ -8,9 +8,9 @@
 
 extern "C"
 {
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeSetEnabled(JNIEnv * env, jclass clazz,
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeSetEnabled(JNIEnv * env, jclass clazz, jboolean enable)
+                                                                                        jboolean enable)
-  {
+{
   GpsTracker::Instance().SetEnabled(enable);
   Framework * const f = frm();
   if (f == nullptr)
@@ -19,41 +19,41 @@ extern "C"
     f->ConnectToGpsTracker();
   else
     f->DisconnectFromGpsTracker();
-  }
+}
-
+
-  JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeIsEnabled(JNIEnv * env, jclass clazz)
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeIsEnabled(JNIEnv * env, jclass clazz)
+{
-  {
+  return GpsTracker::Instance().IsEnabled();
-    return GpsTracker::Instance().IsEnabled();
+}
-  }
+
-
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeStartTrackRecording(JNIEnv * env,
-  JNIEXPORT void JNICALL
+                                                                                                 jclass clazz)
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeStartTrackRecording(JNIEnv * env, jclass clazz)
+{
-  {
+  frm()->StartTrackRecording();
-    frm()->StartTrackRecording();
+}
-  }
+
-
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeStopTrackRecording(JNIEnv * env,
-  JNIEXPORT void JNICALL
+                                                                                                jclass clazz)
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeStopTrackRecording(JNIEnv * env, jclass clazz)
+{
-  {
+  frm()->StopTrackRecording();
-    frm()->StopTrackRecording();
+}
-  }
+
-
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeSaveTrackRecordingWithName(JNIEnv * env,
-  JNIEXPORT void JNICALL
+                                                                                                        jclass clazz,
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeSaveTrackRecordingWithName(JNIEnv * env, jclass clazz, jstring name)
+                                                                                                        jstring name)
-  {
+{
-    frm()->SaveTrackRecordingWithName(jni::ToNativeString(env, name));
+  frm()->SaveTrackRecordingWithName(jni::ToNativeString(env, name));
-  }
+}
-
+
-  JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeIsTrackRecordingEmpty(JNIEnv * env,
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeIsTrackRecordingEmpty(JNIEnv * env, jclass clazz)
+                                                                                                       jclass clazz)
-  {
+{
-    return frm()->IsTrackRecordingEmpty();
+  return frm()->IsTrackRecordingEmpty();
-  }
+}
-
+
-  JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_location_TrackRecorder_nativeIsTrackRecordingEnabled(JNIEnv * env,
-  Java_app_organicmaps_sdk_location_TrackRecorder_nativeIsTrackRecordingEnabled(JNIEnv * env, jclass clazz)
+                                                                                                         jclass clazz)
-  {
+{
-    return frm()->IsTrackRecordingEnabled();
+  return frm()->IsTrackRecordingEnabled();
-  }
+}
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/TrafficState.cpp

@@ -9,39 +9,40 @@ extern "C"
 static void TrafficStateChanged(TrafficManager::TrafficState state, std::shared_ptr<jobject> const & listener)
 {
   JNIEnv * env = jni::GetEnv();
-  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener, "onTrafficStateChanged", "(I)V"), static_cast<jint>(state));
+  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener, "onTrafficStateChanged", "(I)V"),
+                      static_cast<jint>(state));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeSetListener(JNIEnv * env,
-Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeSetListener(JNIEnv * env, jclass clazz, jobject listener)
+                                                                                                jclass clazz,
+                                                                                                jobject listener)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
-  g_framework->SetTrafficStateListener(std::bind(&TrafficStateChanged, std::placeholders::_1, jni::make_global_ref(listener)));
+  g_framework->SetTrafficStateListener(
+      std::bind(&TrafficStateChanged, std::placeholders::_1, jni::make_global_ref(listener)));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeRemoveListener(JNIEnv * env,
-Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeRemoveListener(JNIEnv * env, jclass clazz)
+                                                                                                   jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
   g_framework->SetTrafficStateListener(TrafficManager::TrafficStateChangedFn());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeEnable(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeEnable(JNIEnv * env, jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
   g_framework->EnableTraffic();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeIsEnabled(JNIEnv * env,
-Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeIsEnabled(JNIEnv * env, jclass clazz)
+                                                                                                  jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
   return static_cast<jboolean>(g_framework->IsTrafficEnabled());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeDisable(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_maplayer_traffic_TrafficState_nativeDisable(JNIEnv * env, jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
   g_framework->DisableTraffic();

android/sdk/src/main/cpp/app/organicmaps/sdk/UserMarkHelper.cpp

@@ -27,7 +27,7 @@ void InjectMetadata(JNIEnv * env, jclass const clazz, jobject const mapObject, o
   });
 }
 
-//jobject CreatePopularity(JNIEnv * env, place_page::Info const & info)
+// jobject CreatePopularity(JNIEnv * env, place_page::Info const & info)
 //{
 //   static jclass const popularityClass =
 //     jni::GetGlobalClassRef(env, "app/organicmaps/sdk/search/Popularity");
@@ -35,19 +35,19 @@ void InjectMetadata(JNIEnv * env, jclass const clazz, jobject const mapObject, o
 //     jni::GetConstructorID(env, popularityClass, "(I)V");
 //   auto const popularityValue = info.GetPopularity();
 //   return env->NewObject(popularityClass, popularityConstructor, static_cast<jint>(popularityValue));
-//}
+// }
 
-jobject CreateMapObject(JNIEnv * env, place_page::Info const & info, int mapObjectType,
+jobject CreateMapObject(JNIEnv * env, place_page::Info const & info, int mapObjectType, double lat, double lon,
-                        double lat, double lon, bool parseMeta, bool parseApi,
+                        bool parseMeta, bool parseApi, jobject const & routingPointInfo, jobject const & popularity,
-                        jobject const & routingPointInfo, jobject const & popularity, jobjectArray jrawTypes)
+                        jobjectArray jrawTypes)
 {
   //  public MapObject(@NonNull FeatureId featureId, @MapObjectType int mapObjectType, String title,
   //                   @Nullable String secondaryTitle, String subtitle, String address,
   //                   double lat, double lon, String apiId, @Nullable RoutePointInfo routePointInfo,
   //                   @OpeningMode int openingMode, @NonNull Popularity popularity, @NonNull String description,
   //                   int roadWarningType, @Nullable String[] rawTypes)
-  static jmethodID const ctorId = jni::GetConstructorID(
+  static jmethodID const ctorId =
-      env, g_mapObjectClazz,
+      jni::GetConstructorID(env, g_mapObjectClazz,
                             "("
                             "Lapp/organicmaps/sdk/bookmarks/data/FeatureId;"  // featureId
                             "I"                                               // mapObjectType
@@ -65,39 +65,33 @@ jobject CreateMapObject(JNIEnv * env, place_page::Info const & info, int mapObje
                             "[Ljava/lang/String;"                             // rawTypes
                             ")V");
 
-  //public FeatureId(@NonNull String mwmName, long mwmVersion, int featureIndex)
+  // public FeatureId(@NonNull String mwmName, long mwmVersion, int featureIndex)
-  static jmethodID const featureCtorId =
+  static jmethodID const featureCtorId = jni::GetConstructorID(env, g_featureIdClazz, "(Ljava/lang/String;JI)V");
-      jni::GetConstructorID(env, g_featureIdClazz, "(Ljava/lang/String;JI)V");
 
   auto const fID = info.GetID();
   jni::TScopedLocalRef jMwmName(env, jni::ToJavaString(env, fID.GetMwmName()));
-  jni::TScopedLocalRef jFeatureId(
+  jni::TScopedLocalRef jFeatureId(env, env->NewObject(g_featureIdClazz, featureCtorId, jMwmName.get(),
-      env, env->NewObject(g_featureIdClazz, featureCtorId, jMwmName.get(), (jlong)fID.GetMwmVersion(),
+                                                      (jlong)fID.GetMwmVersion(), (jint)fID.m_index));
-                          (jint)fID.m_index));
   jni::TScopedLocalRef jTitle(env, jni::ToJavaString(env, info.GetTitle()));
   jni::TScopedLocalRef jSecondaryTitle(env, jni::ToJavaString(env, info.GetSecondaryTitle()));
   jni::TScopedLocalRef jSubtitle(env, jni::ToJavaStringWithSupplementalCharsFix(env, info.GetSubtitle()));
   jni::TScopedLocalRef jAddress(env, jni::ToJavaString(env, info.GetSecondarySubtitle()));
   jni::TScopedLocalRef jApiId(env, jni::ToJavaString(env, parseApi ? info.GetApiUrl() : ""));
   jni::TScopedLocalRef jWikiDescription(env, jni::ToJavaString(env, info.GetWikiDescription()));
-  jobject mapObject =
+  jobject mapObject = env->NewObject(g_mapObjectClazz, ctorId, jFeatureId.get(), mapObjectType, jTitle.get(),
-      env->NewObject(g_mapObjectClazz, ctorId, jFeatureId.get(), mapObjectType, jTitle.get(),
                                      jSecondaryTitle.get(), jSubtitle.get(), jAddress.get(), lat, lon, jApiId.get(),
-                     routingPointInfo,
+                                     routingPointInfo, static_cast<jint>(info.GetOpeningMode()), popularity,
-                     static_cast<jint>(info.GetOpeningMode()), popularity, jWikiDescription.get(),
+                                     jWikiDescription.get(), static_cast<jint>(info.GetRoadType()), jrawTypes);
-                     static_cast<jint>(info.GetRoadType()), jrawTypes);
 
   if (parseMeta)
     InjectMetadata(env, g_mapObjectClazz, mapObject, info);
   return mapObject;
 }
 
-jobject CreateBookmark(JNIEnv *env, const place_page::Info &info,
+jobject CreateBookmark(JNIEnv * env, place_page::Info const & info, jni::TScopedLocalObjectArrayRef const & jrawTypes,
-                       const jni::TScopedLocalObjectArrayRef &jrawTypes,
+                       jni::TScopedLocalRef const & routingPointInfo, jobject const & popularity)
-                       const jni::TScopedLocalRef &routingPointInfo,
-                       jobject const & popularity)
 {
-  //public Bookmark(@NonNull FeatureId featureId, @IntRange(from = 0) long categoryId,
+  // public Bookmark(@NonNull FeatureId featureId, @IntRange(from = 0) long categoryId,
   //                 @IntRange(from = 0) long bookmarkId, String title, @Nullable String secondaryTitle,
   //                 @Nullable String subtitle, @Nullable String address, @Nullable RoutePointInfo routePointInfo,
   //                 @OpeningMode int openingMode, @NonNull Popularity popularity, @NonNull String description,
@@ -109,25 +103,22 @@ jobject CreateBookmark(JNIEnv *env, const place_page::Info &info,
                             "Lapp/organicmaps/sdk/routing/RoutePointInfo;"
                             "ILapp/organicmaps/sdk/search/Popularity;Ljava/lang/String;"
                             "[Ljava/lang/String;)V");
-  static jmethodID const featureCtorId =
+  static jmethodID const featureCtorId = jni::GetConstructorID(env, g_featureIdClazz, "(Ljava/lang/String;JI)V");
-          jni::GetConstructorID(env, g_featureIdClazz, "(Ljava/lang/String;JI)V");
 
   auto const bookmarkId = info.GetBookmarkId();
   auto const categoryId = info.GetBookmarkCategoryId();
   jni::TScopedLocalRef jMwmName(env, jni::ToJavaString(env, info.GetID().GetMwmName()));
-  jni::TScopedLocalRef jFeatureId(
+  jni::TScopedLocalRef jFeatureId(env, env->NewObject(g_featureIdClazz, featureCtorId, jMwmName.get(),
-          env, env->NewObject(g_featureIdClazz, featureCtorId, jMwmName.get(),
                                                       (jlong)info.GetID().GetMwmVersion(), (jint)info.GetID().m_index));
   jni::TScopedLocalRef jTitle(env, jni::ToJavaString(env, info.GetTitle()));
   jni::TScopedLocalRef jSecondaryTitle(env, jni::ToJavaString(env, info.GetSecondaryTitle()));
   jni::TScopedLocalRef jSubtitle(env, jni::ToJavaStringWithSupplementalCharsFix(env, info.GetSubtitle()));
   jni::TScopedLocalRef jAddress(env, jni::ToJavaString(env, info.GetSecondarySubtitle()));
   jni::TScopedLocalRef jWikiDescription(env, jni::ToJavaString(env, info.GetWikiDescription()));
-  jobject mapObject = env->NewObject(
+  jobject mapObject = env->NewObject(g_bookmarkClazz, ctorId, jFeatureId.get(), static_cast<jlong>(categoryId),
-          g_bookmarkClazz, ctorId, jFeatureId.get(), static_cast<jlong>(categoryId),
+                                     static_cast<jlong>(bookmarkId), jTitle.get(), jSecondaryTitle.get(),
-          static_cast<jlong>(bookmarkId), jTitle.get(), jSecondaryTitle.get(), jSubtitle.get(),
+                                     jSubtitle.get(), jAddress.get(), routingPointInfo.get(), info.GetOpeningMode(),
-          jAddress.get(), routingPointInfo.get(), info.GetOpeningMode(), popularity,
+                                     popularity, jWikiDescription.get(), jrawTypes.get());
-          jWikiDescription.get(), jrawTypes.get());
 
   if (info.HasMetadata())
     InjectMetadata(env, g_mapObjectClazz, mapObject, info);
@@ -139,9 +130,8 @@ jobject CreateElevationPoint(JNIEnv * env, ElevationInfo::Point const & point)
   static jclass const pointClass =
       jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/ElevationInfo$Point");
   // public Point(double distance, int altitude)
-  static jmethodID const pointCtorId =
+  static jmethodID const pointCtorId = jni::GetConstructorID(env, pointClass, "(DI)V");
-      jni::GetConstructorID(env, pointClass, "(DI)V");
+  return env->NewObject(pointClass, pointCtorId, static_cast<jdouble>(point.m_distance),
-  return env->NewObject(pointClass, pointCtorId, static_cast<jdouble >(point.m_distance),
                         static_cast<jint>(point.m_point.GetAltitude()));
 }
 
@@ -150,11 +140,8 @@ jobjectArray ToElevationPointArray(JNIEnv * env, ElevationInfo::Points const & p
   CHECK(!points.empty(), ("Elevation points must be non empty!"));
   static jclass const pointClass =
       jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/ElevationInfo$Point");
-  return jni::ToJavaArray(env, pointClass, points,
+  return jni::ToJavaArray(env, pointClass, points, [](JNIEnv * env, ElevationInfo::Point const & item)
-                         [](JNIEnv * env, ElevationInfo::Point const & item)
+  { return CreateElevationPoint(env, item); });
-                         {
-                           return CreateElevationPoint(env, item);
-                         });
 }
 
 jobject CreateElevationInfo(JNIEnv * env, ElevationInfo const & info)
@@ -162,18 +149,18 @@ jobject CreateElevationInfo(JNIEnv * env, ElevationInfo const & info)
   // public ElevationInfo(long trackId, @NonNull String name, @NonNull Point[] points,
   //                      int ascent, int descent, int minAltitude, int maxAltitude, int difficulty,
   //                      long m_duration)
-  static jmethodID const ctorId =
+  static jmethodID const ctorId = jni::GetConstructorID(env, g_elevationInfoClazz,
-      jni::GetConstructorID(env, g_elevationInfoClazz, "(JLjava/lang/String;Ljava/lang/String;"
+                                                        "(JLjava/lang/String;Ljava/lang/String;"
                                                         "[Lapp/organicmaps/sdk/bookmarks/data/ElevationInfo$Point;"
                                                         "IIIIIJ)V");
   jni::TScopedLocalObjectArrayRef jPoints(env, ToElevationPointArray(env, info.GetPoints()));
-  // TODO (KK): elevation info should have only the elevation data - see the https://github.com/organicmaps/organicmaps/pull/10063
+  // TODO (KK): elevation info should have only the elevation data - see the
-  return env->NewObject(g_elevationInfoClazz, ctorId,
+  // https://github.com/organicmaps/organicmaps/pull/10063
-                        jPoints.get(),
+  return env->NewObject(g_elevationInfoClazz, ctorId, jPoints.get(),
-//                        static_cast<jint>(info.GetAscent()),
+                        //                        static_cast<jint>(info.GetAscent()),
-//                        static_cast<jint>(info.GetDescent()),
+                        //                        static_cast<jint>(info.GetDescent()),
-//                        static_cast<jint>(info.GetMinAltitude()),
+                        //                        static_cast<jint>(info.GetMinAltitude()),
-//                        static_cast<jint>(info.GetMaxAltitude()),
+                        //                        static_cast<jint>(info.GetMaxAltitude()),
                         static_cast<jint>(info.GetDifficulty()));
 }
 
@@ -185,46 +172,39 @@ jobject CreateMapObject(JNIEnv * env, place_page::Info const & info)
   if (info.IsRoutePoint())
     routingPointInfo.reset(CreateRoutePointInfo(env, info));
 
-  //jni::TScopedLocalRef popularity(env, CreatePopularity(env, info));
+  // jni::TScopedLocalRef popularity(env, CreatePopularity(env, info));
   jobject popularity = nullptr;
 
   if (info.IsBookmark())
-  {
     return CreateBookmark(env, info, jrawTypes, routingPointInfo, popularity);
-  }
 
   ms::LatLon const ll = info.GetLatLon();
   // TODO(yunikkk): object can be POI + API + search result + bookmark simultaneously.
   // TODO(yunikkk): Should we pass localized strings here and in other methods as byte arrays?
   if (info.IsMyPosition())
   {
-    return CreateMapObject(env, info, kMyPosition, ll.m_lat, ll.m_lon,
+    return CreateMapObject(env, info, kMyPosition, ll.m_lat, ll.m_lon, false /* parseMeta */, false /* parseApi */,
-                           false /* parseMeta */, false /* parseApi */,
                            routingPointInfo.get(), popularity, jrawTypes.get());
   }
 
   if (info.HasApiUrl())
   {
-    return CreateMapObject(env, info, kApiPoint, ll.m_lat, ll.m_lon,
+    return CreateMapObject(env, info, kApiPoint, ll.m_lat, ll.m_lon, true /* parseMeta */, true /* parseApi */,
-                           true /* parseMeta */, true /* parseApi */,
                            routingPointInfo.get(), popularity, jrawTypes.get());
   }
 
-  return CreateMapObject(env, info, kPoi, ll.m_lat, ll.m_lon,
+  return CreateMapObject(env, info, kPoi, ll.m_lat, ll.m_lon, true /* parseMeta */, false /* parseApi */,
-                         true /* parseMeta */, false /* parseApi */,
                          routingPointInfo.get(), popularity, jrawTypes.get());
 }
 
 jobject CreateFeatureId(JNIEnv * env, FeatureID const & fid)
 {
-  static jmethodID const featureCtorId =
+  static jmethodID const featureCtorId = jni::GetConstructorID(env, g_featureIdClazz, "(Ljava/lang/String;JI)V");
-    jni::GetConstructorID(env, g_featureIdClazz, "(Ljava/lang/String;JI)V");
 
   auto const & info = fid.m_mwmId.GetInfo();
   jni::TScopedLocalRef jMwmName(env, jni::ToJavaString(env, info ? info->GetCountryName() : ""));
   return env->NewObject(g_featureIdClazz, featureCtorId, jMwmName.get(),
-                        info ? static_cast<jlong>(info->GetVersion()) : 0,
+                        info ? static_cast<jlong>(info->GetVersion()) : 0, static_cast<jint>(fid.m_index));
-                        static_cast<jint>(fid.m_index));
 }
 
 jobjectArray ToFeatureIdArray(JNIEnv * env, std::vector<FeatureID> const & ids)
@@ -233,8 +213,6 @@ jobjectArray ToFeatureIdArray(JNIEnv * env, std::vector<FeatureID> const & ids)
     return nullptr;
 
   return jni::ToJavaArray(env, g_featureIdClazz, ids,
-                          [](JNIEnv * env, FeatureID const & fid) {
+                          [](JNIEnv * env, FeatureID const & fid) { return CreateFeatureId(env, fid); });
-                            return CreateFeatureId(env, fid);
-                          });
 }
 }  // namespace usermark_helper

android/sdk/src/main/cpp/app/organicmaps/sdk/UserMarkHelper.hpp

@@ -2,8 +2,8 @@
 
 #include <jni.h>
 
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/Framework.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 
 #include <vector>
 

android/sdk/src/main/cpp/app/organicmaps/sdk/bookmarks/data/BookmarkManager.cpp

@@ -1,12 +1,11 @@
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/Framework.hpp"
 #include "app/organicmaps/sdk/UserMarkHelper.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/util/Distance.hpp"
 
 #include "map/bookmark_helpers.hpp"
 #include "map/place_page_info.hpp"
 
-
 #include "coding/zip_creator.hpp"
 
 #include "platform/localization.hpp"
@@ -44,61 +43,47 @@ jmethodID g_onBookmarksSortingCancelled;
 jmethodID g_bookmarkInfoConstructor;
 jclass g_bookmarkInfoClass;
 
-
 void PrepareClassRefs(JNIEnv * env)
 {
   if (g_bookmarkManagerClass)
     return;
 
-  g_bookmarkManagerClass =
+  g_bookmarkManagerClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkManager");
-    jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkManager");
   g_bookmarkManagerInstanceField = jni::GetStaticFieldID(env, g_bookmarkManagerClass, "INSTANCE",
                                                          "Lapp/organicmaps/sdk/bookmarks/data/BookmarkManager;");
 
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
+  g_onBookmarksChangedMethod = jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksChanged", "()V");
-  g_onBookmarksChangedMethod =
-    jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksChanged", "()V");
   g_onBookmarksLoadingStartedMethod =
       jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksLoadingStarted", "()V");
   g_onBookmarksLoadingFinishedMethod =
       jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksLoadingFinished", "()V");
   g_onBookmarksFileLoadedMethod =
-    jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksFileLoaded",
+      jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksFileLoaded", "(ZLjava/lang/String;Z)V");
-                     "(ZLjava/lang/String;Z)V");
+  g_onPreparedFileForSharingMethod = jni::GetMethodID(env, bookmarkManagerInstance, "onPreparedFileForSharing",
-  g_onPreparedFileForSharingMethod =
-    jni::GetMethodID(env, bookmarkManagerInstance, "onPreparedFileForSharing",
                                                       "(Lapp/organicmaps/sdk/bookmarks/data/BookmarkSharingResult;)V");
 
-  g_longClass = jni::GetGlobalClassRef(env,"java/lang/Long");
+  g_longClass = jni::GetGlobalClassRef(env, "java/lang/Long");
   g_longConstructor = jni::GetConstructorID(env, g_longClass, "(J)V");
-  g_sortedBlockClass =
+  g_sortedBlockClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/SortedBlock");
-    jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/SortedBlock");
   g_sortedBlockConstructor =
-    jni::GetConstructorID(env, g_sortedBlockClass,
+      jni::GetConstructorID(env, g_sortedBlockClass, "(Ljava/lang/String;[Ljava/lang/Long;[Ljava/lang/Long;)V");
-                          "(Ljava/lang/String;[Ljava/lang/Long;[Ljava/lang/Long;)V");
 
+  g_onBookmarksSortingCompleted = jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksSortingCompleted",
+                                                   "([Lapp/organicmaps/sdk/bookmarks/data/SortedBlock;J)V");
+  g_onBookmarksSortingCancelled = jni::GetMethodID(env, bookmarkManagerInstance, "onBookmarksSortingCancelled", "(J)V");
+  g_bookmarkInfoClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkInfo");
+  g_bookmarkInfoConstructor = jni::GetConstructorID(env, g_bookmarkInfoClass, "(JJ)V");
+  g_bookmarkCategoryClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkCategory");
 
-  g_onBookmarksSortingCompleted = jni::GetMethodID(env, bookmarkManagerInstance,
+  // public BookmarkCategory(long id,
-    "onBookmarksSortingCompleted", "([Lapp/organicmaps/sdk/bookmarks/data/SortedBlock;J)V");
+  //                           String name,
-  g_onBookmarksSortingCancelled = jni::GetMethodID(env, bookmarkManagerInstance,
+  //                           String annotation,
-    "onBookmarksSortingCancelled", "(J)V");
+  //                           String desc,
-  g_bookmarkInfoClass =
+  //                           int tracksCount,
-    jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkInfo");
+  //                           int bookmarksCount,
-  g_bookmarkInfoConstructor =
+  //                           boolean isVisible)
-    jni::GetConstructorID(env, g_bookmarkInfoClass, "(JJ)V" );
+  g_bookmarkCategoryConstructor = jni::GetConstructorID(env, g_bookmarkCategoryClass,
-  g_bookmarkCategoryClass =
-    jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkCategory");
-
-//public BookmarkCategory(long id,
-//                          String name,
-//                          String annotation,
-//                          String desc,
-//                          int tracksCount,
-//                          int bookmarksCount,
-//                          boolean isVisible)
-  g_bookmarkCategoryConstructor =
-      jni::GetConstructorID(env, g_bookmarkCategoryClass,
                                                         "("
                                                         "J"                   // id
                                                         "Ljava/lang/String;"  // name
@@ -117,8 +102,7 @@ void PrepareClassRefs(JNIEnv * env)
 void OnElevationCurPositionChanged(JNIEnv * env)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance =
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-      env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
   env->CallVoidMethod(bookmarkManagerInstance, g_onElevationCurrentPositionChangedMethod);
   jni::HandleJavaException(env);
 }
@@ -126,8 +110,7 @@ void OnElevationCurPositionChanged(JNIEnv * env)
 void OnElevationActivePointChanged(JNIEnv * env)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
   env->CallVoidMethod(bookmarkManagerInstance, g_onElevationActivePointChangedMethod);
   jni::HandleJavaException(env);
 }
@@ -135,8 +118,7 @@ void OnElevationActivePointChanged(JNIEnv * env)
 void OnBookmarksChanged(JNIEnv * env)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
   env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksChangedMethod);
   jni::HandleJavaException(env);
 }
@@ -144,8 +126,7 @@ void OnBookmarksChanged(JNIEnv * env)
 void OnAsyncLoadingStarted(JNIEnv * env)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
   env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksLoadingStartedMethod);
   jni::HandleJavaException(env);
 }
@@ -153,8 +134,7 @@ void OnAsyncLoadingStarted(JNIEnv * env)
 void OnAsyncLoadingFinished(JNIEnv * env)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
   env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksLoadingFinishedMethod);
   jni::HandleJavaException(env);
 }
@@ -162,41 +142,44 @@ void OnAsyncLoadingFinished(JNIEnv * env)
 void OnAsyncLoadingFileSuccess(JNIEnv * env, std::string const & fileName, bool isTemporaryFile)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
   jni::TScopedLocalRef jFileName(env, jni::ToJavaString(env, fileName));
-  env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksFileLoadedMethod,
+  env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksFileLoadedMethod, true /* success */, jFileName.get(),
-                      true /* success */, jFileName.get(), isTemporaryFile);
+                      isTemporaryFile);
   jni::HandleJavaException(env);
 }
 
 void OnAsyncLoadingFileError(JNIEnv * env, std::string const & fileName, bool isTemporaryFile)
 {
   ASSERT(g_bookmarkManagerClass, ());
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
   jni::TScopedLocalRef jFileName(env, jni::ToJavaString(env, fileName));
-  env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksFileLoadedMethod,
+  env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksFileLoadedMethod, false /* success */, jFileName.get(),
-                      false /* success */, jFileName.get(), isTemporaryFile);
+                      isTemporaryFile);
   jni::HandleJavaException(env);
 }
 
 void OnPreparedFileForSharing(JNIEnv * env, BookmarkManager::SharingResult const & result)
 {
-  static jclass const classBookmarkSharingResult = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkSharingResult");
+  static jclass const classBookmarkSharingResult =
-  // BookmarkSharingResult(long[] categoriesIds, @Code int code, @NonNull String sharingPath, @NonNull String mimeType, @NonNull String errorString)
+      jni::GetGlobalClassRef(env, "app/organicmaps/sdk/bookmarks/data/BookmarkSharingResult");
-  static jmethodID const ctorBookmarkSharingResult = jni::GetConstructorID(env, classBookmarkSharingResult, "([JILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+  // BookmarkSharingResult(long[] categoriesIds, @Code int code, @NonNull String sharingPath, @NonNull String mimeType,
+  // @NonNull String errorString)
+  static jmethodID const ctorBookmarkSharingResult = jni::GetConstructorID(
+      env, classBookmarkSharingResult, "([JILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
 
   static_assert(sizeof(jlong) == sizeof(decltype(result.m_categoriesIds)::value_type));
   jsize const categoriesIdsSize = static_cast<jsize>(result.m_categoriesIds.size());
   jni::ScopedLocalRef<jlongArray> categoriesIds(env, env->NewLongArray(categoriesIdsSize));
-  env->SetLongArrayRegion(categoriesIds.get(), 0, categoriesIdsSize, reinterpret_cast<jlong const *>(result.m_categoriesIds.data()));
+  env->SetLongArrayRegion(categoriesIds.get(), 0, categoriesIdsSize,
+                          reinterpret_cast<jlong const *>(result.m_categoriesIds.data()));
   jni::TScopedLocalRef const sharingPath(env, jni::ToJavaString(env, result.m_sharingPath));
   jni::TScopedLocalRef const mimeType(env, jni::ToJavaString(env, result.m_mimeType));
   jni::TScopedLocalRef const errorString(env, jni::ToJavaString(env, result.m_errorString));
 
-  jni::TScopedLocalRef const sharingResult(env, env->NewObject(classBookmarkSharingResult, ctorBookmarkSharingResult,
+  jni::TScopedLocalRef const sharingResult(
-      categoriesIds.get(), static_cast<jint>(result.m_code), sharingPath.get(), mimeType.get(), errorString.get()));
+      env, env->NewObject(classBookmarkSharingResult, ctorBookmarkSharingResult, categoriesIds.get(),
+                          static_cast<jint>(result.m_code), sharingPath.get(), mimeType.get(), errorString.get()));
 
   ASSERT(g_bookmarkManagerClass, ());
   jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
@@ -212,45 +195,34 @@ void OnCategorySortingResults(JNIEnv * env, long long timestamp,
   ASSERT(g_sortedBlockClass, ());
   ASSERT(g_sortedBlockConstructor, ());
 
-  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass,
+  jobject bookmarkManagerInstance = env->GetStaticObjectField(g_bookmarkManagerClass, g_bookmarkManagerInstanceField);
-                                                              g_bookmarkManagerInstanceField);
 
   if (status == BookmarkManager::SortParams::Status::Cancelled)
   {
-    env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksSortingCancelled,
+    env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksSortingCancelled, static_cast<jlong>(timestamp));
-                        static_cast<jlong>(timestamp));
     jni::HandleJavaException(env);
     return;
   }
 
-  jni::TScopedLocalObjectArrayRef blocksRef(env,
+  jni::TScopedLocalObjectArrayRef blocksRef(
-      jni::ToJavaArray(env, g_sortedBlockClass, sortedBlocks,
+      env, jni::ToJavaArray(env, g_sortedBlockClass, sortedBlocks,
                             [](JNIEnv * env, BookmarkManager::SortedBlock const & block)
   {
     jni::TScopedLocalRef blockNameRef(env, jni::ToJavaString(env, block.m_blockName));
 
-            jni::TScopedLocalObjectArrayRef marksRef(env,
+    jni::TScopedLocalObjectArrayRef marksRef(
-                jni::ToJavaArray(env, g_longClass, block.m_markIds,
+        env, jni::ToJavaArray(env, g_longClass, block.m_markIds, [](JNIEnv * env, kml::MarkId const & markId)
-                    [](JNIEnv * env, kml::MarkId const & markId)
+    { return env->NewObject(g_longClass, g_longConstructor, static_cast<jlong>(markId)); }));
-                    {
-                      return env->NewObject(g_longClass, g_longConstructor,
-                          static_cast<jlong>(markId));
-                    }));
 
-            jni::TScopedLocalObjectArrayRef tracksRef(env,
+    jni::TScopedLocalObjectArrayRef tracksRef(
-                jni::ToJavaArray(env, g_longClass, block.m_trackIds,
+        env, jni::ToJavaArray(env, g_longClass, block.m_trackIds, [](JNIEnv * env, kml::TrackId const & trackId)
-                    [](JNIEnv * env, kml::TrackId const & trackId)
+    { return env->NewObject(g_longClass, g_longConstructor, static_cast<jlong>(trackId)); }));
-                    {
-                      return env->NewObject(g_longClass, g_longConstructor,
-                          static_cast<jlong>(trackId));
-                    }));
-
-            return env->NewObject(g_sortedBlockClass, g_sortedBlockConstructor,
-                                 blockNameRef.get(), marksRef.get(), tracksRef.get());
 
+    return env->NewObject(g_sortedBlockClass, g_sortedBlockConstructor, blockNameRef.get(), marksRef.get(),
+                          tracksRef.get());
   }));
-  env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksSortingCompleted,
+  env->CallVoidMethod(bookmarkManagerInstance, g_onBookmarksSortingCompleted, blocksRef.get(),
-                      blocksRef.get(), static_cast<jlong>(timestamp));
+                      static_cast<jlong>(timestamp));
   jni::HandleJavaException(env);
 }
 
@@ -277,14 +249,9 @@ jobject MakeCategory(JNIEnv * env, kml::MarkGroupId id)
   jni::TScopedLocalRef annotationRef(env, jni::ToJavaString(env, annotation));
   jni::TScopedLocalRef descriptionRef(env, jni::ToJavaString(env, description));
 
-  return env->NewObject(g_bookmarkCategoryClass,
+  return env->NewObject(g_bookmarkCategoryClass, g_bookmarkCategoryConstructor, static_cast<jlong>(data.m_id),
-                        g_bookmarkCategoryConstructor,
+                        preferBookmarkStrRef.get(), annotationRef.get(), descriptionRef.get(),
-                        static_cast<jlong>(data.m_id),
+                        static_cast<jint>(tracksCount), static_cast<jint>(bookmarksCount),
-                        preferBookmarkStrRef.get(),
-                        annotationRef.get(),
-                        descriptionRef.get(),
-                        static_cast<jint>(tracksCount),
-                        static_cast<jint>(bookmarksCount),
                         static_cast<jboolean>(isVisible));
 }
 
@@ -296,22 +263,20 @@ jobjectArray MakeCategories(JNIEnv * env, kml::GroupIdCollection const & ids)
 
 extern "C"
 {
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeShowBookmarkOnMap(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeShowBookmarkOnMap(
+                                                                                                       jobject,
-    JNIEnv *, jobject, jlong bmkId)
+                                                                                                       jlong bmkId)
 {
   frm()->ShowBookmark(static_cast<kml::MarkId>(bmkId));
 }
 
 JNIEXPORT void JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeShowBookmarkCategoryOnMap(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeShowBookmarkCategoryOnMap(JNIEnv *, jobject, jlong catId)
-    JNIEnv *, jobject, jlong catId)
 {
   frm()->ShowBookmarkCategory(static_cast<kml::MarkGroupId>(catId), true /* animated */);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeLoadBookmarks(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeLoadBookmarks(JNIEnv * env, jclass)
 {
   PrepareClassRefs(env);
   BookmarkManager::AsyncLoadingCallbacks callbacks;
@@ -326,39 +291,38 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeLoadBookmarks(JNIE
   frm()->LoadBookmarks();
 }
 
-JNIEXPORT jlong JNICALL
+JNIEXPORT jlong JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeCreateCategory(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeCreateCategory(
+                                                                                                     jobject,
-     JNIEnv * env, jobject, jstring name)
+                                                                                                     jstring name)
 {
   auto const categoryId = frm()->GetBookmarkManager().CreateBookmarkCategory(ToNativeString(env, name));
   frm()->GetBookmarkManager().SetLastEditedBmCategory(categoryId);
   return static_cast<jlong>(categoryId);
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeDeleteCategory(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeDeleteCategory(
+                                                                                                        jobject,
-     JNIEnv *, jobject, jlong catId)
+                                                                                                        jlong catId)
 {
   auto const categoryId = static_cast<kml::MarkGroupId>(catId);
   // `permanently` should be set to false when the Recently Deleted Lists feature be implemented
-  return static_cast<jboolean>(frm()->GetBookmarkManager().GetEditSession().DeleteBmCategory(categoryId, true /* permanently */));
+  return static_cast<jboolean>(
+      frm()->GetBookmarkManager().GetEditSession().DeleteBmCategory(categoryId, true /* permanently */));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeDeleteBookmark(JNIEnv *, jobject,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeDeleteBookmark(JNIEnv *, jobject, jlong bmkId)
+                                                                                                    jlong bmkId)
 {
   frm()->GetBookmarkManager().GetEditSession().DeleteBookmark(static_cast<kml::MarkId>(bmkId));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeDeleteTrack(JNIEnv *, jobject,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeDeleteTrack(
+                                                                                                 jlong trkId)
-    JNIEnv *, jobject, jlong trkId)
 {
   frm()->GetBookmarkManager().GetEditSession().DeleteTrack(static_cast<kml::TrackId>(trkId));
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAddBookmarkToLastEditedCategory(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAddBookmarkToLastEditedCategory(
     JNIEnv * env, jobject, double lat, double lon)
 {
   if (!frm()->HasPlacePageInfo())
@@ -377,8 +341,7 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAddBookmarkToLastE
   if (info.IsFeature())
     SaveFeatureTypes(info.GetTypes(), bmData);
 
-  auto const * createdBookmark = bmMng.GetEditSession().CreateBookmark(std::move(bmData),
+  auto const * createdBookmark = bmMng.GetEditSession().CreateBookmark(std::move(bmData), lastEditedCategory);
-    lastEditedCategory);
 
   auto buildInfo = info.GetBuildInfo();
   buildInfo.m_match = place_page::BuildInfo::Match::Everything;
@@ -388,23 +351,20 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAddBookmarkToLastE
   return usermark_helper::CreateMapObject(env, g_framework->GetPlacePageInfo());
 }
 
-JNIEXPORT jlong JNICALL
+JNIEXPORT jlong JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastEditedCategory(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastEditedCategory(
+                                                                                                            jobject)
-      JNIEnv *, jobject)
 {
   return static_cast<jlong>(frm()->LastEditedBMCategory());
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastEditedColor(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastEditedColor(
+                                                                                                        jobject)
-        JNIEnv *, jobject)
 {
   return static_cast<jint>(frm()->LastEditedBMColor());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeLoadBookmarksFile(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeLoadBookmarksFile(JNIEnv * env, jclass,
+    JNIEnv * env, jclass, jstring path, jboolean isTemporaryFile)
-                                                                                jstring path, jboolean isTemporaryFile)
 {
   frm()->AddBookmarksFile(ToNativeString(env, path), isTemporaryFile);
 }
@@ -415,40 +375,36 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsAsyncBookmarksLo
   return static_cast<jboolean>(frm()->GetBookmarkManager().IsAsyncLoadingInProgress());
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsVisible(JNIEnv *, jobject,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsVisible(
+                                                                                                   jlong catId)
-    JNIEnv *, jobject, jlong catId)
 {
   return static_cast<jboolean>(frm()->GetBookmarkManager().IsVisible(static_cast<kml::MarkGroupId>(catId)));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetVisibility(JNIEnv *, jobject,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetVisibility(
+                                                                                                   jlong catId,
-    JNIEnv *, jobject, jlong catId, jboolean isVisible)
+                                                                                                   jboolean isVisible)
 {
   frm()->GetBookmarkManager().GetEditSession().SetIsVisible(static_cast<kml::MarkGroupId>(catId), isVisible);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryName(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryName(
+                                                                                                     jobject,
-    JNIEnv * env, jobject, jlong catId, jstring name)
+                                                                                                     jlong catId,
+                                                                                                     jstring name)
 {
   frm()->GetBookmarkManager().GetEditSession().SetCategoryName(static_cast<kml::MarkGroupId>(catId),
                                                                jni::ToNativeString(env, name));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryDescription(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryDescription(JNIEnv * env,
+    JNIEnv * env, jobject, jlong catId, jstring desc)
-                                                                                     jobject,
-                                                                                     jlong catId,
-                                                                                     jstring desc)
 {
-  frm()->GetBookmarkManager().GetEditSession().SetCategoryDescription(
+  frm()->GetBookmarkManager().GetEditSession().SetCategoryDescription(static_cast<kml::MarkGroupId>(catId),
-      static_cast<kml::MarkGroupId>(catId), jni::ToNativeString(env, desc));
+                                                                      jni::ToNativeString(env, desc));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryTags(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryTags(
     JNIEnv * env, jobject, jlong catId, jobjectArray tagsIds)
 {
   auto const size = env->GetArrayLength(tagsIds);
@@ -460,28 +416,24 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryTags(
     categoryTags.push_back(jni::ToNativeString(env, static_cast<jstring>(item.get())));
   }
 
-  frm()->GetBookmarkManager().GetEditSession().SetCategoryTags(static_cast<kml::MarkGroupId>(catId),
+  frm()->GetBookmarkManager().GetEditSession().SetCategoryTags(static_cast<kml::MarkGroupId>(catId), categoryTags);
-                                                               categoryTags);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryAccessRules(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryAccessRules(
     JNIEnv *, jobject, jlong catId, jint accessRules)
 {
-  frm()->GetBookmarkManager().GetEditSession().SetCategoryAccessRules(
+  frm()->GetBookmarkManager().GetEditSession().SetCategoryAccessRules(static_cast<kml::MarkGroupId>(catId),
-    static_cast<kml::MarkGroupId>(catId), static_cast<kml::AccessRules>(accessRules));
+                                                                      static_cast<kml::AccessRules>(accessRules));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryCustomProperty(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetCategoryCustomProperty(
     JNIEnv * env, jobject, jlong catId, jstring key, jstring value)
 {
   frm()->GetBookmarkManager().GetEditSession().SetCategoryCustomProperty(
       static_cast<kml::MarkGroupId>(catId), ToNativeString(env, key), ToNativeString(env, value));
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeUpdateBookmarkPlacePage(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeUpdateBookmarkPlacePage(
     JNIEnv * env, jobject, jlong bmkId)
 {
   if (!frm()->HasPlacePageInfo())
@@ -495,20 +447,18 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeUpdateBookmarkPlac
   return usermark_helper::CreateMapObject(env, g_framework->GetPlacePageInfo());
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkInfo(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkInfo(
+                                                                                                        jobject,
-  JNIEnv * env, jobject, jlong bmkId)
+                                                                                                        jlong bmkId)
 {
   auto const bookmark = frm()->GetBookmarkManager().GetBookmark(static_cast<kml::MarkId>(bmkId));
   if (!bookmark)
     return nullptr;
-  return env->NewObject(g_bookmarkInfoClass,
+  return env->NewObject(g_bookmarkInfoClass, g_bookmarkInfoConstructor, static_cast<jlong>(bookmark->GetGroupId()),
-                        g_bookmarkInfoConstructor, static_cast<jlong>(bookmark->GetGroupId()),
                         static_cast<jlong>(bmkId));
 }
 
-JNIEXPORT jlong JNICALL
+JNIEXPORT jlong JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkIdByPosition(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkIdByPosition(
     JNIEnv *, jobject, jlong catId, jint positionInCategory)
 {
   auto const & ids = frm()->GetBookmarkManager().GetUserMarkIds(static_cast<kml::MarkGroupId>(catId));
@@ -519,15 +469,18 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkIdByPos
   return static_cast<jlong>(*it);
 }
 
-static uint32_t shift(uint32_t v, uint8_t bitCount) { return v << bitCount; }
+static uint32_t shift(uint32_t v, uint8_t bitCount)
+{
+  return v << bitCount;
+}
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrack(JNIEnv * env, jobject,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrack(
+                                                                                                 jlong trackId,
-      JNIEnv * env, jobject, jlong trackId, jclass trackClazz)
+                                                                                                 jclass trackClazz)
 {
   // Track(long trackId, long categoryId, String name, String lengthString, int color)
-  static jmethodID const cId = jni::GetConstructorID(env, trackClazz,
+  static jmethodID const cId =
-                                                     "(JJLjava/lang/String;Lapp/organicmaps/sdk/util/Distance;I)V");
+      jni::GetConstructorID(env, trackClazz, "(JJLjava/lang/String;Lapp/organicmaps/sdk/util/Distance;I)V");
   auto const * nTrack = frm()->GetBookmarkManager().GetTrack(static_cast<kml::TrackId>(trackId));
 
   ASSERT(nTrack, ("Track must not be null with id:)", trackId));
@@ -538,8 +491,7 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrack(
                         nTrack->GetColor(0).GetARGB());
 }
 
-JNIEXPORT jlong JNICALL
+JNIEXPORT jlong JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrackIdByPosition(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrackIdByPosition(
     JNIEnv *, jobject, jlong catId, jint positionInCategory)
 {
   auto const & ids = frm()->GetBookmarkManager().GetTrackIds(static_cast<kml::MarkGroupId>(catId));
@@ -551,92 +503,82 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrackIdByPositi
 }
 
 JNIEXPORT jboolean JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsUsedCategoryName(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsUsedCategoryName(JNIEnv * env, jclass, jstring name)
-        JNIEnv * env, jclass, jstring name)
 {
   return static_cast<jboolean>(frm()->GetBookmarkManager().IsUsedCategoryName(ToNativeString(env, name)));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativePrepareForSearch(JNIEnv *, jclass,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativePrepareForSearch(
+                                                                                                      jlong catId)
-        JNIEnv *, jclass, jlong catId)
 {
   frm()->GetBookmarkManager().PrepareForSearch(static_cast<kml::MarkGroupId>(catId));
 }
 
 JNIEXPORT jboolean JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAreAllCategoriesInvisible(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAreAllCategoriesInvisible(JNIEnv *, jclass)
-        JNIEnv *, jclass)
 {
   return static_cast<jboolean>(frm()->GetBookmarkManager().AreAllCategoriesInvisible());
 }
 
 JNIEXPORT jboolean JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAreAllCategoriesVisible(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAreAllCategoriesVisible(JNIEnv *, jclass)
-        JNIEnv *, jclass)
 {
   return static_cast<jboolean>(frm()->GetBookmarkManager().AreAllCategoriesVisible());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetAllCategoriesVisibility(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetAllCategoriesVisibility(
     JNIEnv *, jclass, jboolean visible)
 {
   frm()->GetBookmarkManager().SetAllCategoriesVisibility(static_cast<bool>(visible));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativePrepareTrackFileForSharing(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativePrepareTrackFileForSharing(JNIEnv * env, jclass, jlong trackId, jint kmlFileType)
+    JNIEnv * env, jclass, jlong trackId, jint kmlFileType)
 {
-  frm()->GetBookmarkManager().PrepareTrackFileForSharing(static_cast<kml::TrackId>(trackId), [env](BookmarkManager::SharingResult const & result)
+  frm()->GetBookmarkManager().PrepareTrackFileForSharing(static_cast<kml::TrackId>(trackId),
-                                                    {
+                                                         [env](BookmarkManager::SharingResult const & result)
-                                                      OnPreparedFileForSharing(env, result);
+  { OnPreparedFileForSharing(env, result); }, static_cast<KmlFileType>(kmlFileType));
-                                                    }, static_cast<KmlFileType>(kmlFileType));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativePrepareFileForSharing(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativePrepareFileForSharing(JNIEnv * env, jclass, jlongArray catIds, jint kmlFileType)
+    JNIEnv * env, jclass, jlongArray catIds, jint kmlFileType)
 {
   auto const size = env->GetArrayLength(catIds);
   kml::GroupIdCollection catIdsVector(size);
   static_assert(sizeof(jlong) == sizeof(decltype(catIdsVector)::value_type));
   env->GetLongArrayRegion(catIds, 0, size, reinterpret_cast<jlong *>(catIdsVector.data()));
-  frm()->GetBookmarkManager().PrepareFileForSharing(std::move(catIdsVector), [env](BookmarkManager::SharingResult const & result)
+  frm()->GetBookmarkManager().PrepareFileForSharing(std::move(catIdsVector),
-  {
+                                                    [env](BookmarkManager::SharingResult const & result)
-    OnPreparedFileForSharing(env, result);
+  { OnPreparedFileForSharing(env, result); }, static_cast<KmlFileType>(kmlFileType));
-  }, static_cast<KmlFileType>(kmlFileType));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsCategoryEmpty(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeIsCategoryEmpty(
+                                                                                                         jclass,
-        JNIEnv *, jclass, jlong catId)
+                                                                                                         jlong catId)
 {
-  return static_cast<jboolean>(frm()->GetBookmarkManager().IsCategoryEmpty(
+  return static_cast<jboolean>(frm()->GetBookmarkManager().IsCategoryEmpty(static_cast<kml::MarkGroupId>(catId)));
-    static_cast<kml::MarkGroupId>(catId)));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetNotificationsEnabled(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetNotificationsEnabled(
     JNIEnv *, jclass, jboolean enabled)
 {
   frm()->GetBookmarkManager().SetNotificationsEnabled(static_cast<bool>(enabled));
 }
 
 JNIEXPORT jboolean JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAreNotificationsEnabled(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeAreNotificationsEnabled(JNIEnv *, jclass)
-        JNIEnv *, jclass)
 {
   return static_cast<jboolean>(frm()->GetBookmarkManager().AreNotificationsEnabled());
 }
 
 JNIEXPORT jobject JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategory(JNIEnv *env, jobject, jlong id)
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategory(JNIEnv * env, jobject, jlong id)
 {
   return MakeCategory(env, static_cast<kml::MarkGroupId>(id));
 }
 
 JNIEXPORT jobjectArray JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategories(JNIEnv *env, jobject)
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategories(JNIEnv * env, jobject)
 {
   auto const & bm = frm()->GetBookmarkManager();
   auto const & ids = bm.GetSortedBmGroupIdList();
@@ -645,7 +587,7 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategor
 }
 
 JNIEXPORT jint JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategoriesCount(JNIEnv *env, jobject)
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategoriesCount(JNIEnv * env, jobject)
 {
   auto const & bm = frm()->GetBookmarkManager();
   auto const count = bm.GetBmGroupsCount();
@@ -653,8 +595,8 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkCategor
   return static_cast<jint>(count);
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetChildrenCategories(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetChildrenCategories(JNIEnv *env, jobject, jlong parentId)
+    JNIEnv * env, jobject, jlong parentId)
 {
   auto const & bm = frm()->GetBookmarkManager();
   auto const ids = bm.GetChildrenCategories(static_cast<kml::MarkGroupId>(parentId));
@@ -662,18 +604,18 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetChildrenCategor
   return MakeCategories(env, ids);
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeHasLastSortingType(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeHasLastSortingType(
+                                                                                                            jobject,
-    JNIEnv *, jobject, jlong catId)
+                                                                                                            jlong catId)
 {
   auto const & bm = frm()->GetBookmarkManager();
   BookmarkManager::SortingType type;
   return static_cast<jboolean>(bm.GetLastSortingType(static_cast<kml::MarkGroupId>(catId), type));
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastSortingType(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastSortingType(
+                                                                                                        jobject,
-    JNIEnv *, jobject, jlong catId)
+                                                                                                        jlong catId)
 {
   auto const & bm = frm()->GetBookmarkManager();
   BookmarkManager::SortingType type;
@@ -683,30 +625,29 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetLastSortingType
   return static_cast<jint>(type);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetLastSortingType(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetLastSortingType(
+                                                                                                        jobject,
-    JNIEnv *, jobject, jlong catId, jint type)
+                                                                                                        jlong catId,
+                                                                                                        jint type)
 {
   auto & bm = frm()->GetBookmarkManager();
-  bm.SetLastSortingType(static_cast<kml::MarkGroupId>(catId),
+  bm.SetLastSortingType(static_cast<kml::MarkGroupId>(catId), static_cast<BookmarkManager::SortingType>(type));
-      static_cast<BookmarkManager::SortingType>(type));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeResetLastSortingType(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeResetLastSortingType(
+                                                                                                          jobject,
-    JNIEnv *, jobject, jlong catId)
+                                                                                                          jlong catId)
 {
   auto & bm = frm()->GetBookmarkManager();
   bm.ResetLastSortingType(static_cast<kml::MarkGroupId>(catId));
 }
 
-JNIEXPORT jintArray JNICALL
+JNIEXPORT jintArray JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetAvailableSortingTypes(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetAvailableSortingTypes(JNIEnv *env,
+    JNIEnv * env, jobject, jlong catId, jboolean hasMyPosition)
-    jobject, jlong catId, jboolean hasMyPosition)
 {
   auto const & bm = frm()->GetBookmarkManager();
-  auto const types =  bm.GetAvailableSortingTypes(static_cast<kml::MarkGroupId>(catId),
+  auto const types =
-                                                  static_cast<bool>(hasMyPosition));
+      bm.GetAvailableSortingTypes(static_cast<kml::MarkGroupId>(catId), static_cast<bool>(hasMyPosition));
   int const size = static_cast<int>(types.size());
   jintArray jTypes = env->NewIntArray(size);
   jint * arr = env->GetIntArrayElements(jTypes, 0);
@@ -717,9 +658,8 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetAvailableSortin
   return jTypes;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetSortedCategory(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetSortedCategory(JNIEnv *env,
+    JNIEnv * env, jobject, jlong catId, jint sortingType, jboolean hasMyPosition, jdouble lat, jdouble lon,
-    jobject, jlong catId, jint sortingType, jboolean hasMyPosition, jdouble lat, jdouble lon,
     jlong timestamp)
 {
   auto & bm = frm()->GetBookmarkManager();
@@ -727,57 +667,47 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetSortedCategory(
   sortParams.m_groupId = static_cast<kml::MarkGroupId>(catId);
   sortParams.m_sortingType = static_cast<BookmarkManager::SortingType>(sortingType);
   sortParams.m_hasMyPosition = static_cast<bool>(hasMyPosition);
-  sortParams.m_myPosition = mercator::FromLatLon(static_cast<double>(lat),
+  sortParams.m_myPosition = mercator::FromLatLon(static_cast<double>(lat), static_cast<double>(lon));
-      static_cast<double>(lon));
   sortParams.m_onResults = bind(&OnCategorySortingResults, env, timestamp, _1, _2);
 
   bm.GetSortedCategory(sortParams);
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkName(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkName(
+                                                                                                        jclass,
-  JNIEnv * env, jclass, jlong bmk)
+                                                                                                        jlong bmk)
 {
   return jni::ToJavaString(env, getBookmark(bmk)->GetPreferredName());
 }
 
 JNIEXPORT jstring JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkFeatureType(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkFeatureType(JNIEnv * env, jclass, jlong bmk)
-  JNIEnv * env, jclass, jlong bmk)
 {
-  return jni::ToJavaString(env,
+  return jni::ToJavaString(env, kml::GetLocalizedFeatureType(getBookmark(bmk)->GetData().m_featureTypes));
-    kml::GetLocalizedFeatureType(getBookmark(bmk)->GetData().m_featureTypes));
 }
 
 JNIEXPORT jstring JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkDescription(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkDescription(JNIEnv * env, jclass, jlong bmk)
-  JNIEnv * env, jclass, jlong bmk)
 {
   return jni::ToJavaString(env, getBookmark(bmk)->GetDescription());
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkColor(JNIEnv *, jclass,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkColor(
+                                                                                                      jlong bmk)
-  JNIEnv *, jclass, jlong bmk)
 {
   auto const * mark = getBookmark(bmk);
-  return static_cast<jint>(mark != nullptr ? mark->GetColor()
+  return static_cast<jint>(mark != nullptr ? mark->GetColor() : frm()->LastEditedBMColor());
-                                           : frm()->LastEditedBMColor());
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkIcon(JNIEnv *, jclass,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkIcon(
+                                                                                                     jlong bmk)
-  JNIEnv *, jclass, jlong bmk)
 {
   auto const * mark = getBookmark(bmk);
-  return static_cast<jint>(mark != nullptr ? mark->GetData().m_icon
+  return static_cast<jint>(mark != nullptr ? mark->GetData().m_icon : kml::BookmarkIcon::None);
-                                           : kml::BookmarkIcon::None);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetBookmarkParams(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetBookmarkParams(
+    JNIEnv * env, jclass, jlong bmk, jstring name, jint color, jstring descr)
-  JNIEnv * env, jclass, jlong bmk,
-  jstring name, jint color, jstring descr)
 {
   auto const * mark = getBookmark(bmk);
 
@@ -793,12 +723,13 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetBookmarkParams(
   g_framework->ReplaceBookmark(static_cast<kml::MarkId>(bmk), bmData);
 }
 
-constexpr static uint8_t ExtractByte(uint32_t number, uint8_t byteIdx) { return (number >> (8 * byteIdx)) & 0xFF; }
+constexpr static uint8_t ExtractByte(uint32_t number, uint8_t byteIdx)
+{
+  return (number >> (8 * byteIdx)) & 0xFF;
+}
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetTrackParams(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetTrackParams(
+    JNIEnv * env, jclass, jlong trackId, jstring name, jint color, jstring descr)
-    JNIEnv * env, jclass, jlong trackId,
-    jstring name, jint color, jstring descr)
 {
   auto const * nTrack = frm()->GetBookmarkManager().GetTrack(static_cast<kml::TrackId>(trackId));
   CHECK(nTrack, ("Track must not be null with id:", trackId));
@@ -809,73 +740,69 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetTrackParams(
   kml::SetDefaultStr(trackData.m_description, jni::ToNativeString(env, descr));
 
   uint8_t alpha = ExtractByte(color, 3);
-  trackData.m_layers[0].m_color.m_rgba = static_cast<uint32_t>(shift(color,8) + alpha);
+  trackData.m_layers[0].m_color.m_rgba = static_cast<uint32_t>(shift(color, 8) + alpha);
 
   g_framework->ReplaceTrack(static_cast<kml::TrackId>(trackId), trackData);
 }
 
 JNIEXPORT jstring JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrackDescription(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetTrackDescription(JNIEnv * env, jclass, jlong trackId)
-    JNIEnv * env, jclass, jlong trackId)
 {
-  return jni::ToJavaString(env, frm()->GetBookmarkManager().GetTrack(static_cast<kml::TrackId>(trackId))->GetDescription());
+  return jni::ToJavaString(env,
+                           frm()->GetBookmarkManager().GetTrack(static_cast<kml::TrackId>(trackId))->GetDescription());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeChangeBookmarkCategory(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeChangeBookmarkCategory(
     JNIEnv *, jclass, jlong oldCat, jlong newCat, jlong bmk)
 {
   g_framework->MoveBookmark(static_cast<kml::MarkId>(bmk), static_cast<kml::MarkGroupId>(oldCat),
                             static_cast<kml::MarkGroupId>(newCat));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeChangeTrackCategory(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeChangeTrackCategory(
     JNIEnv *, jclass, jlong oldCat, jlong newCat, jlong trackId)
 {
   g_framework->MoveTrack(static_cast<kml::TrackId>(trackId), static_cast<kml::MarkGroupId>(oldCat),
                          static_cast<kml::MarkGroupId>(newCat));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeChangeTrackColor(JNIEnv *, jclass,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeChangeTrackColor(
+                                                                                                      jlong trackId,
-  JNIEnv *, jclass, jlong trackId, jint color)
+                                                                                                      jint color)
 {
   uint8_t alpha = ExtractByte(color, 3);
-  g_framework->ChangeTrackColor(static_cast<kml::TrackId>(trackId), static_cast<dp::Color>(shift(color,8) + alpha));
+  g_framework->ChangeTrackColor(static_cast<kml::TrackId>(trackId), static_cast<dp::Color>(shift(color, 8) + alpha));
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkXY(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkXY(
+                                                                                                      jclass, jlong bmk)
-  JNIEnv * env, jclass, jlong bmk)
 {
   return jni::GetNewParcelablePointD(env, getBookmark(bmk)->GetPivot());
 }
 
-JNIEXPORT jdouble JNICALL
+JNIEXPORT jdouble JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkScale(JNIEnv *,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkScale(
+                                                                                                         jclass,
-  JNIEnv *, jclass, jlong bmk)
+                                                                                                         jlong bmk)
 {
   return getBookmark(bmk)->GetScale();
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeEncode2Ge0Url(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeEncode2Ge0Url(
+                                                                                                      jclass, jlong bmk,
-  JNIEnv * env, jclass, jlong bmk, jboolean addName)
+                                                                                                      jboolean addName)
 {
   return jni::ToJavaString(env, frm()->CodeGe0url(getBookmark(bmk), addName));
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkAddress(JNIEnv * env,
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetBookmarkAddress(
+                                                                                                           jclass,
-  JNIEnv * env, jclass, jlong bmkId)
+                                                                                                           jlong bmkId)
 {
   auto const address = frm()->GetAddressAtPoint(getBookmark(bmkId)->GetPivot()).FormatAddress();
   return jni::ToJavaString(env, address);
 }
 
-JNIEXPORT jdouble JNICALL
+JNIEXPORT jdouble JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetElevationCurPositionDistance(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetElevationCurPositionDistance(
     JNIEnv *, jclass, jlong trackId)
 {
   auto const & bm = frm()->GetBookmarkManager();
@@ -883,32 +810,31 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetElevationCurPos
 }
 
 JNIEXPORT void JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetElevationCurrentPositionChangedListener(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetElevationCurrentPositionChangedListener(JNIEnv * env,
-        JNIEnv * env, jclass)
+                                                                                                         jclass)
 {
-  frm()->GetBookmarkManager().SetElevationMyPositionChangedCallback(
+  frm()->GetBookmarkManager().SetElevationMyPositionChangedCallback(std::bind(&OnElevationCurPositionChanged, env));
-      std::bind(&OnElevationCurPositionChanged, env));
 }
 
 JNIEXPORT void JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeRemoveElevationCurrentPositionChangedListener(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeRemoveElevationCurrentPositionChangedListener(JNIEnv *,
-        JNIEnv *, jclass)
+                                                                                                            jclass)
 {
   frm()->GetBookmarkManager().SetElevationMyPositionChangedCallback(nullptr);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetElevationActivePoint(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetElevationActivePoint(
     JNIEnv *, jclass, jlong trackId, jdouble distanceInMeters)
 {
   auto & bm = frm()->GetBookmarkManager();
-  bm.SetElevationActivePoint(static_cast<kml::TrackId>(trackId),
+  bm.SetElevationActivePoint(
-                             {0,0}, // todo(KK): replace with coordinates from the elevation profile point to show selection mark on the track
+      static_cast<kml::TrackId>(trackId),
+      {0,
+       0},  // todo(KK): replace with coordinates from the elevation profile point to show selection mark on the track
       static_cast<double>(distanceInMeters));
 }
 
-JNIEXPORT jdouble JNICALL
+JNIEXPORT jdouble JNICALL Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetElevationActivePointDistance(
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetElevationActivePointDistance(
     JNIEnv *, jclass, jlong trackId)
 {
   auto & bm = frm()->GetBookmarkManager();
@@ -916,15 +842,13 @@ Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeGetElevationActive
 }
 
 JNIEXPORT void JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetElevationActiveChangedListener(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeSetElevationActiveChangedListener(JNIEnv * env, jclass)
-   JNIEnv *env, jclass)
 {
   frm()->GetBookmarkManager().SetElevationActivePointChangedCallback(std::bind(&OnElevationActivePointChanged, env));
 }
 
 JNIEXPORT void JNICALL
-Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeRemoveElevationActiveChangedListener(
+Java_app_organicmaps_sdk_bookmarks_data_BookmarkManager_nativeRemoveElevationActiveChangedListener(JNIEnv *, jclass)
-        JNIEnv *, jclass)
 {
   frm()->GetBookmarkManager().SetElevationActivePointChangedCallback(nullptr);
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/core/ScopedLocalRef.hpp

@@ -6,7 +6,8 @@ namespace jni
 {
 // A smart pointer that deletes a JNI local reference when it goes out of scope.
 template <typename T>
-class ScopedLocalRef {
+class ScopedLocalRef
+{
 public:
   ScopedLocalRef(JNIEnv * env, T localRef) : m_env(env), m_localRef(localRef) {}
 

android/sdk/src/main/cpp/app/organicmaps/sdk/core/jni_helper.cpp

@@ -6,8 +6,8 @@
 #include "base/exception.hpp"
 #include "base/string_utils.hpp"
 
-#include "app/organicmaps/sdk/bookmarks/data/PredefinedColors.hpp"
 #include "app/organicmaps/sdk/bookmarks/data/Icon.hpp"
+#include "app/organicmaps/sdk/bookmarks/data/PredefinedColors.hpp"
 
 #include <vector>
 
@@ -36,7 +36,7 @@ int __system_property_get(char const * name, char * value);
 
 static bool IsAndroidApiLowerThan(int apiLevel)
 {
-  char value[92] = { 0 };
+  char value[92] = {0};
   if (__system_property_get("ro.build.version.sdk", value) < 1)
     return false;
   int const deviceApiLevel = atoi(value);
@@ -78,8 +78,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM * jvm, void *)
   return JNI_VERSION_1_6;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *, void *)
-JNI_OnUnload(JavaVM *, void *)
 {
   g_jvm = 0;
   JNIEnv * env = jni::GetEnv();
@@ -187,11 +186,11 @@ jstring ToJavaStringWithSupplementalCharsFix(JNIEnv * env, std::string const & s
   if (g_isAndroidLowerThan7)
   {
     // Detect 4-byte sequence start marker to avoid unnecessary allocation + copy.
-    for (const auto c : s)
+    for (auto const c : s)
     {
       if (0b11110000 == (c & 0b11111000))
       {
-        const auto utf16 = strings::ToUtf16(s);
+        auto const utf16 = strings::ToUtf16(s);
         return env->NewString(reinterpret_cast<jchar const *>(utf16.data()), utf16.size());
       }
     }
@@ -219,19 +218,17 @@ std::shared_ptr<jobject> make_global_ref(jobject obj)
   });
 }
 
-std::string ToNativeString(JNIEnv * env, const jthrowable & e)
+std::string ToNativeString(JNIEnv * env, jthrowable const & e)
 {
   jni::TScopedLocalClassRef logClassRef(env, env->FindClass("android/util/Log"));
   ASSERT(logClassRef.get(), ());
-  static jmethodID const getStacktraceMethod =
+  static jmethodID const getStacktraceMethod = jni::GetStaticMethodID(env, logClassRef.get(), "getStackTraceString",
-    jni::GetStaticMethodID(env, logClassRef.get(), "getStackTraceString",
                                                                       "(Ljava/lang/Throwable;)Ljava/lang/String;");
   ASSERT(getStacktraceMethod, ());
   TScopedLocalRef resultRef(env, env->CallStaticObjectMethod(logClassRef.get(), getStacktraceMethod, e));
-  return ToNativeString(env, (jstring) resultRef.get());
+  return ToNativeString(env, (jstring)resultRef.get());
 }
 
-
 bool HandleJavaException(JNIEnv * env)
 {
   if (env->ExceptionCheck())
@@ -246,12 +243,11 @@ bool HandleJavaException(JNIEnv * env)
   return false;
 }
 
-base::LogLevel GetLogLevelForException(JNIEnv * env, const jthrowable & e)
+base::LogLevel GetLogLevelForException(JNIEnv * env, jthrowable const & e)
 {
   static jclass const errorClass = jni::GetGlobalClassRef(env, "java/lang/Error");
   ASSERT(errorClass, (jni::DescribeException()));
-  static jclass const runtimeExceptionClass =
+  static jclass const runtimeExceptionClass = jni::GetGlobalClassRef(env, "java/lang/RuntimeException");
-    jni::GetGlobalClassRef(env, "java/lang/RuntimeException");
   ASSERT(runtimeExceptionClass, (jni::DescribeException()));
   // If Unchecked Exception or Error is occurred during Java call the app should fail immediately.
   // In other cases, just a warning message about exception (Checked Exception)
@@ -281,12 +277,10 @@ std::string DescribeException()
 jobject GetNewParcelablePointD(JNIEnv * env, m2::PointD const & point)
 {
   jclass klass = env->FindClass("app/organicmaps/sdk/bookmarks/data/ParcelablePointD");
-  ASSERT ( klass, () );
+  ASSERT(klass, ());
   jmethodID methodID = GetConstructorID(env, klass, "(DD)V");
 
-  return env->NewObject(klass, methodID,
+  return env->NewObject(klass, methodID, static_cast<jdouble>(point.x), static_cast<jdouble>(point.y));
-                        static_cast<jdouble>(point.x),
-                        static_cast<jdouble>(point.y));
 }
 
 jobject GetNewPoint(JNIEnv * env, m2::PointD const & point)
@@ -297,12 +291,10 @@ jobject GetNewPoint(JNIEnv * env, m2::PointD const & point)
 jobject GetNewPoint(JNIEnv * env, m2::PointI const & point)
 {
   jclass klass = env->FindClass("android/graphics/Point");
-  ASSERT ( klass, () );
+  ASSERT(klass, ());
   jmethodID methodID = GetConstructorID(env, klass, "(II)V");
 
-  return env->NewObject(klass, methodID,
+  return env->NewObject(klass, methodID, static_cast<jint>(point.x), static_cast<jint>(point.y));
-                        static_cast<jint>(point.x),
-                        static_cast<jint>(point.y));
 }
 
 // This util method dumps content of local and global reference jni tables to logcat for debug and testing purposes
@@ -317,8 +309,8 @@ void DumpDalvikReferenceTables()
 
 jobject ToKeyValue(JNIEnv * env, std::pair<std::string, std::string> src)
 {
-  static jmethodID const keyValueInit = jni::GetConstructorID(
+  static jmethodID const keyValueInit =
-    env, g_keyValueClazz, "(Ljava/lang/String;Ljava/lang/String;)V");
+      jni::GetConstructorID(env, g_keyValueClazz, "(Ljava/lang/String;Ljava/lang/String;)V");
 
   jni::TScopedLocalRef key(env, jni::ToJavaString(env, src.first));
   jni::TScopedLocalRef value(env, jni::ToJavaString(env, src.second));
@@ -328,16 +320,12 @@ jobject ToKeyValue(JNIEnv * env, std::pair<std::string, std::string> src)
 
 std::pair<std::string, std::string> ToNativeKeyValue(JNIEnv * env, jobject pairOfStrings)
 {
-  static jfieldID const keyId = env->GetFieldID(g_keyValueClazz, "mKey",
+  static jfieldID const keyId = env->GetFieldID(g_keyValueClazz, "mKey", "Ljava/lang/String;");
-                                                  "Ljava/lang/String;");
+  static jfieldID const valueId = env->GetFieldID(g_keyValueClazz, "mValue", "Ljava/lang/String;");
-  static jfieldID const valueId = env->GetFieldID(g_keyValueClazz, "mValue",
-                                                   "Ljava/lang/String;");
 
-  jni::ScopedLocalRef<jstring> const key(
+  jni::ScopedLocalRef<jstring> const key(env, static_cast<jstring>(env->GetObjectField(pairOfStrings, keyId)));
-    env, static_cast<jstring>(env->GetObjectField(pairOfStrings, keyId)));
+  jni::ScopedLocalRef<jstring> const value(env, static_cast<jstring>(env->GetObjectField(pairOfStrings, valueId)));
-  jni::ScopedLocalRef<jstring> const value(
-    env, static_cast<jstring>(env->GetObjectField(pairOfStrings, valueId)));
 
-  return { jni::ToNativeString(env, key.get()), jni::ToNativeString(env, value.get()) };
+  return {jni::ToNativeString(env, key.get()), jni::ToNativeString(env, value.get())};
 }
 }  // namespace jni

android/sdk/src/main/cpp/app/organicmaps/sdk/core/jni_helper.hpp

@@ -41,8 +41,8 @@ jfieldID GetStaticFieldID(JNIEnv * env, jclass clazz, char const * name, char co
 jclass GetGlobalClassRef(JNIEnv * env, char const * s);
 
 std::string ToNativeString(JNIEnv * env, jstring str);
-// Converts UTF-8 array to native UTF-8 string. Result differs from simple GetStringUTFChars call for characters greater than U+10000,
+// Converts UTF-8 array to native UTF-8 string. Result differs from simple GetStringUTFChars call for characters greater
-// since jni uses modified UTF (MUTF-8) for strings.
+// than U+10000, since jni uses modified UTF (MUTF-8) for strings.
 std::string ToNativeString(JNIEnv * env, jbyteArray const & utfBytes);
 jstring ToJavaString(JNIEnv * env, char const * s);
 inline jstring ToJavaString(JNIEnv * env, std::string const & s)
@@ -63,7 +63,7 @@ char const * GetStringClassName();
 
 std::string DescribeException();
 bool HandleJavaException(JNIEnv * env);
-base::LogLevel GetLogLevelForException(JNIEnv * env, const jthrowable & e);
+base::LogLevel GetLogLevelForException(JNIEnv * env, jthrowable const & e);
 
 std::shared_ptr<jobject> make_global_ref(jobject obj);
 using TScopedLocalRef = ScopedLocalRef<jobject>;
@@ -77,10 +77,10 @@ jobject GetNewParcelablePointD(JNIEnv * env, m2::PointD const & point);
 jobject GetNewPoint(JNIEnv * env, m2::PointD const & point);
 jobject GetNewPoint(JNIEnv * env, m2::PointI const & point);
 
-template<typename TIt, typename TToJavaFn>
+template <typename TIt, typename TToJavaFn>
 jobjectArray ToJavaArray(JNIEnv * env, jclass clazz, TIt begin, TIt end, size_t const size, TToJavaFn && toJavaFn)
 {
-  jobjectArray jArray = env->NewObjectArray((jint) size, clazz, 0);
+  jobjectArray jArray = env->NewObjectArray((jint)size, clazz, 0);
   jint i = 0;
   for (auto it = begin; it != end; ++it)
   {
@@ -92,21 +92,17 @@ jobjectArray ToJavaArray(JNIEnv * env, jclass clazz, TIt begin, TIt end, size_t
   return jArray;
 }
 
-template<typename TContainer, typename TToJavaFn>
+template <typename TContainer, typename TToJavaFn>
 jobjectArray ToJavaArray(JNIEnv * env, jclass clazz, TContainer const & src, TToJavaFn && toJavaFn)
 {
-  return ToJavaArray(env, clazz, std::begin(src), std::end(src), src.size(),
+  return ToJavaArray(env, clazz, std::begin(src), std::end(src), src.size(), std::forward<TToJavaFn>(toJavaFn));
-                     std::forward<TToJavaFn>(toJavaFn));
 }
 
 template <typename Cont>
 jobjectArray ToJavaStringArray(JNIEnv * env, Cont const & src)
 {
   return ToJavaArray(env, GetStringClass(env), src,
-                     [](JNIEnv * env, std::string const & item)
+                     [](JNIEnv * env, std::string const & item) { return ToJavaString(env, item.c_str()); });
-                     {
-                       return ToJavaString(env, item.c_str());
-                     });
 }
 
 void DumpDalvikReferenceTables();

android/sdk/src/main/cpp/app/organicmaps/sdk/core/jni_java_methods.hpp

@@ -2,8 +2,12 @@
 
 #include <jni.h>
 
-#define DECLARE_BUILDER_INSTANCE(BuilderType) static BuilderType const & Instance(JNIEnv * env) { \
+#define DECLARE_BUILDER_INSTANCE(BuilderType)       \
-                                              static BuilderType const inst(env); return inst; }
+  static BuilderType const & Instance(JNIEnv * env) \
+  {                                                 \
+    static BuilderType const inst(env);             \
+    return inst;                                    \
+  }
 
 namespace jni
 {

android/sdk/src/main/cpp/app/organicmaps/sdk/core/logging.cpp

@@ -3,9 +3,9 @@
 #include "base/exception.hpp"
 #include "base/logging.hpp"
 
+#include "app/organicmaps/sdk/core/ScopedEnv.hpp"
 #include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/core/logging.hpp"
-#include "app/organicmaps/sdk/core/ScopedEnv.hpp"
 
 #include <android/log.h>
 #include <cassert>
@@ -31,8 +31,8 @@ void AndroidMessage(LogLevel level, SrcPoint const & src, std::string const & s)
   }
 
   ScopedEnv env(jni::GetJVM());
-  static jmethodID const logMethod = jni::GetStaticMethodID(env.get(), g_loggerClazz,
+  static jmethodID const logMethod = jni::GetStaticMethodID(
-     "log", "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V");
+      env.get(), g_loggerClazz, "log", "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V");
 
   std::string const out = DebugPrint(src) + s;
   jni::TScopedLocalRef msg(env.get(), jni::ToJavaString(env.get(), out));
@@ -68,4 +68,4 @@ void ToggleDebugLogs(bool enabled)
   else
     g_LogLevel = LINFO;
 }
-}
+}  // namespace jni

android/sdk/src/main/cpp/app/organicmaps/sdk/core/logging.hpp

@@ -2,7 +2,7 @@
 
 namespace jni
 {
-  void InitSystemLog();
+void InitSystemLog();
-  void InitAssertLog();
+void InitAssertLog();
-  void ToggleDebugLogs(bool enabled);
+void ToggleDebugLogs(bool enabled);
-}
+}  // namespace jni

android/sdk/src/main/cpp/app/organicmaps/sdk/core/render_context.cpp

@@ -2,16 +2,12 @@
 
 namespace android
 {
-  void RenderContext::makeCurrent()
+void RenderContext::makeCurrent() {}
-  {
-  }
 
-  graphics::RenderContext * RenderContext::createShared()
+graphics::RenderContext * RenderContext::createShared()
-  {
+{
   RenderContext * rc = new RenderContext();
   rc->setResourceManager(resourceManager());
   return rc;
-  }
 }
-
+}  // namespace android
-

android/sdk/src/main/cpp/app/organicmaps/sdk/core/render_context.hpp

@@ -6,12 +6,11 @@
 
 namespace android
 {
-  class RenderContext : public graphics::gl::RenderContext
+class RenderContext : public graphics::gl::RenderContext
-  {
+{
-  public:
+public:
-
   void makeCurrent();
 
   graphics::RenderContext * createShared();
-  };
+};
-}
+}  // namespace android

android/sdk/src/main/cpp/app/organicmaps/sdk/editor/Editor.cpp

@@ -1,7 +1,7 @@
 #include <jni.h>
 
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/Framework.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 
 #include "editor/osm_editor.hpp"
 
@@ -43,8 +43,7 @@ jobject ToJavaName(JNIEnv * env, osm::LocalizedName const & name)
   jni::TScopedLocalRef jName(env, jni::ToJavaString(env, name.m_name));
   jni::TScopedLocalRef jLang(env, jni::ToJavaString(env, name.m_lang));
   jni::TScopedLocalRef jLangName(env, jni::ToJavaString(env, name.m_langName));
-  return env->NewObject(g_localNameClazz, g_localNameCtor, name.m_code,
+  return env->NewObject(g_localNameClazz, g_localNameCtor, name.m_code, jName.get(), jLang.get(), jLangName.get());
-                        jName.get(), jLang.get(), jLangName.get());
 }
 
 jobject ToJavaStreet(JNIEnv * env, osm::LocalizedStreet const & street)
@@ -65,12 +64,12 @@ extern "C"
 {
 using osm::Editor;
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeInit(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeInit(JNIEnv * env, jclass)
 {
   g_localNameClazz = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/editor/data/LocalizedName");
   // LocalizedName(int code, @NonNull String name, @NonNull String lang, @NonNull String langName)
-  g_localNameCtor = jni::GetConstructorID(env, g_localNameClazz, "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+  g_localNameCtor =
+      jni::GetConstructorID(env, g_localNameClazz, "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
   g_localNameFieldCode = env->GetFieldID(g_localNameClazz, "code", "I");
   g_localNameFieldName = env->GetFieldID(g_localNameClazz, "name", "Ljava/lang/String;");
 
@@ -81,23 +80,21 @@ Java_app_organicmaps_sdk_editor_Editor_nativeInit(JNIEnv * env, jclass)
   g_localStreetFieldLoc = env->GetFieldID(g_localStreetClazz, "localizedName", "Ljava/lang/String;");
 
   g_namesDataSourceClassID = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/editor/data/NamesDataSource");
-  g_namesDataSourceConstructorID = jni::GetConstructorID(env, g_namesDataSourceClassID, "([Lapp/organicmaps/sdk/editor/data/LocalizedName;I)V");
+  g_namesDataSourceConstructorID =
+      jni::GetConstructorID(env, g_namesDataSourceClassID, "([Lapp/organicmaps/sdk/editor/data/LocalizedName;I)V");
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetOpeningHours(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetOpeningHours(JNIEnv * env, jclass)
 {
   return jni::ToJavaString(env, g_editableMapObject.GetOpeningHours());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetOpeningHours(JNIEnv * env, jclass, jstring value)
-Java_app_organicmaps_sdk_editor_Editor_nativeSetOpeningHours(JNIEnv * env, jclass, jstring value)
 {
   g_editableMapObject.SetOpeningHours(jni::ToNativeString(env, value));
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetMetadata(JNIEnv * env, jclass, jint id)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetMetadata(JNIEnv * env, jclass, jint id)
 {
   auto const metaID = static_cast<osm::MapObject::MetadataID>(id);
   ASSERT_LESS(metaID, osm::MapObject::MetadataID::FMD_COUNT, ());
@@ -112,64 +109,56 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetMetadata(JNIEnv * env, jclass, j
   return jni::ToJavaString(env, g_editableMapObject.GetMetadata(metaID));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsMetadataValid(JNIEnv * env, jclass, jint id,
-Java_app_organicmaps_sdk_editor_Editor_nativeIsMetadataValid(JNIEnv * env, jclass, jint id, jstring value)
+                                                                                        jstring value)
 {
   auto const metaID = static_cast<osm::MapObject::MetadataID>(id);
   ASSERT_LESS(metaID, osm::MapObject::MetadataID::FMD_COUNT, ());
   return osm::EditableMapObject::IsValidMetadata(metaID, jni::ToNativeString(env, value));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetMetadata(JNIEnv * env, jclass, jint id,
-Java_app_organicmaps_sdk_editor_Editor_nativeSetMetadata(JNIEnv * env, jclass, jint id, jstring value)
+                                                                                jstring value)
 {
   auto const metaID = static_cast<osm::MapObject::MetadataID>(id);
   ASSERT_LESS(metaID, osm::MapObject::MetadataID::FMD_COUNT, ());
   g_editableMapObject.SetMetadata(metaID, jni::ToNativeString(env, value));
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetStars(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetStars(JNIEnv * env, jclass)
 {
   return g_editableMapObject.GetStars();
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetMaxEditableBuildingLevels(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetMaxEditableBuildingLevels(JNIEnv *, jclass)
 {
   return osm::EditableMapObject::kMaximumLevelsEditableByUsers;
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeHasWifi(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeHasWifi(JNIEnv *, jclass)
 {
   return g_editableMapObject.GetInternet() == feature::Internet::Wlan;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetHasWifi(JNIEnv *, jclass, jboolean hasWifi)
-Java_app_organicmaps_sdk_editor_Editor_nativeSetHasWifi(JNIEnv *, jclass, jboolean hasWifi)
 {
   if (hasWifi != (g_editableMapObject.GetInternet() == feature::Internet::Wlan))
     g_editableMapObject.SetInternet(hasWifi ? feature::Internet::Wlan : feature::Internet::Unknown);
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSaveEditedFeature(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeSaveEditedFeature(JNIEnv *, jclass)
 {
   switch (g_framework->NativeFramework()->SaveEditedMapObject(g_editableMapObject))
   {
   case osm::Editor::SaveResult::NothingWasChanged:
-  case osm::Editor::SaveResult::SavedSuccessfully:
+  case osm::Editor::SaveResult::SavedSuccessfully: return true;
-    return true;
   case osm::Editor::SaveResult::NoFreeSpaceError:
   case osm::Editor::SaveResult::NoUnderlyingMapError:
-  case osm::Editor::SaveResult::SavingError:
+  case osm::Editor::SaveResult::SavingError: return false;
-    return false;
   }
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowEditPlace(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowEditPlace(JNIEnv *, jclass)
 {
   ::Framework * frm = g_framework->NativeFramework();
   if (!frm->HasPlacePageInfo())
@@ -178,8 +167,7 @@ Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowEditPlace(JNIEnv *, jclas
   return g_framework->GetPlacePageInfo().ShouldShowEditPlace();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowAddBusiness(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowAddBusiness(JNIEnv *, jclass)
 {
   ::Framework * frm = g_framework->NativeFramework();
   if (!frm->HasPlacePageInfo())
@@ -188,8 +176,7 @@ Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowAddBusiness(JNIEnv *, jcl
   return g_framework->GetPlacePageInfo().ShouldShowAddBusiness();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowAddPlace(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowAddPlace(JNIEnv *, jclass)
 {
   ::Framework * frm = g_framework->NativeFramework();
   if (!frm->HasPlacePageInfo())
@@ -198,8 +185,7 @@ Java_app_organicmaps_sdk_editor_Editor_nativeShouldShowAddPlace(JNIEnv *, jclass
   return g_framework->GetPlacePageInfo().ShouldShowAddPlace();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeShouldEnableEditPlace(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeShouldEnableEditPlace(JNIEnv *, jclass)
 {
   ::Framework * frm = g_framework->NativeFramework();
   if (!frm->HasPlacePageInfo())
@@ -208,8 +194,7 @@ Java_app_organicmaps_sdk_editor_Editor_nativeShouldEnableEditPlace(JNIEnv *, jcl
   return g_framework->GetPlacePageInfo().ShouldEnableEditPlace();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeShouldEnableAddPlace(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeShouldEnableAddPlace(JNIEnv *, jclass)
 {
   ::Framework * frm = g_framework->NativeFramework();
   if (!frm->HasPlacePageInfo())
@@ -218,8 +203,8 @@ Java_app_organicmaps_sdk_editor_Editor_nativeShouldEnableAddPlace(JNIEnv *, jcla
   return g_framework->GetPlacePageInfo().ShouldEnableAddPlace();
 }
 
-JNIEXPORT jintArray JNICALL
+JNIEXPORT jintArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetEditableProperties(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_Editor_nativeGetEditableProperties(JNIEnv * env, jclass clazz)
+                                                                                               jclass clazz)
 {
   auto const & editable = g_editableMapObject.GetEditableProperties();
   size_t const size = editable.size();
@@ -232,32 +217,27 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetEditableProperties(JNIEnv * env,
   return jEditableFields;
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsAddressEditable(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeIsAddressEditable(JNIEnv * env, jclass clazz)
 {
   return g_editableMapObject.IsAddressEditable();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsNameEditable(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeIsNameEditable(JNIEnv * env, jclass clazz)
 {
   return g_editableMapObject.IsNameEditable();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsPointType(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeIsPointType(JNIEnv * env, jclass clazz)
 {
   return g_editableMapObject.IsPointType();
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsBuilding(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeIsBuilding(JNIEnv * env, jclass clazz)
 {
   return g_editableMapObject.IsBuilding();
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetNamesDataSource(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetNamesDataSource(JNIEnv * env, jclass)
 {
   auto const namesDataSource = g_editableMapObject.GetNamesDataSource();
 
@@ -267,41 +247,39 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetNamesDataSource(JNIEnv * env, jc
   return env->NewObject(g_namesDataSourceClassID, g_namesDataSourceConstructorID, names, mandatoryNamesCount);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetNames(JNIEnv * env, jclass, jobjectArray names)
-Java_app_organicmaps_sdk_editor_Editor_nativeSetNames(JNIEnv * env, jclass, jobjectArray names)
 {
   int const length = env->GetArrayLength(names);
   for (int i = 0; i < length; i++)
   {
     auto jName = env->GetObjectArrayElement(names, i);
-    g_editableMapObject.SetName(jni::ToNativeString(env, static_cast<jstring>(env->GetObjectField(jName, g_localNameFieldName))),
+    g_editableMapObject.SetName(
+        jni::ToNativeString(env, static_cast<jstring>(env->GetObjectField(jName, g_localNameFieldName))),
         env->GetIntField(jName, g_localNameFieldCode));
   }
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetStreet(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetStreet(JNIEnv * env, jclass)
 {
   return ToJavaStreet(env, g_editableMapObject.GetStreet());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetStreet(JNIEnv * env, jclass, jobject street)
-Java_app_organicmaps_sdk_editor_Editor_nativeSetStreet(JNIEnv * env, jclass, jobject street)
 {
-  g_editableMapObject.SetStreet({jni::ToNativeString(env, (jstring) env->GetObjectField(street, g_localStreetFieldDef)),
+  g_editableMapObject.SetStreet(
-                                 jni::ToNativeString(env, (jstring) env->GetObjectField(street, g_localStreetFieldLoc))});
+      {jni::ToNativeString(env, (jstring)env->GetObjectField(street, g_localStreetFieldDef)),
+       jni::ToNativeString(env, (jstring)env->GetObjectField(street, g_localStreetFieldLoc))});
 }
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetNearbyStreets(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetNearbyStreets(JNIEnv * env, jclass clazz)
 {
   return jni::ToJavaArray(env, g_localStreetClazz, g_editableMapObject.GetNearbyStreets(), ToJavaStreet);
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetSupportedLanguages(
-Java_app_organicmaps_sdk_editor_Editor_nativeGetSupportedLanguages(JNIEnv * env, jclass clazz, jboolean includeServiceLangs)
+    JNIEnv * env, jclass clazz, jboolean includeServiceLangs)
 {
   using TLang = StringUtf8Multilang::Lang;
-  //public Language(@NonNull String code, @NonNull String name)
+  // public Language(@NonNull String code, @NonNull String name)
   static jclass const langClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/editor/data/Language");
   static jmethodID const langCtor = jni::GetConstructorID(env, langClass, "(Ljava/lang/String;Ljava/lang/String;)V");
 
@@ -314,35 +292,34 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetSupportedLanguages(JNIEnv * env,
   });
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetHouseNumber(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetHouseNumber(JNIEnv * env, jclass)
 {
   return jni::ToJavaString(env, g_editableMapObject.GetHouseNumber());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetHouseNumber(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_Editor_nativeSetHouseNumber(JNIEnv * env, jclass, jstring houseNumber)
+                                                                                   jstring houseNumber)
 {
   g_editableMapObject.SetHouseNumber(jni::ToNativeString(env, houseNumber));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeHasSomethingToUpload(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeHasSomethingToUpload(JNIEnv * env, jclass clazz)
 {
   return Editor::Instance().HaveMapEditsOrNotesToUpload();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeUploadChanges(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_Editor_nativeUploadChanges(JNIEnv * env, jclass clazz, jstring token, jstring appVersion, jstring appId)
+                                                                                  jstring token, jstring appVersion,
+                                                                                  jstring appId)
 {
   // TODO: Handle upload status in callback
   Editor::Instance().UploadChanges(jni::ToNativeString(env, token),
                                    {{"created_by", "CoMaps " OMIM_OS_NAME " " + jni::ToNativeString(env, appVersion)},
-       {"bundle_id", jni::ToNativeString(env, appId)}}, nullptr);
+                                    {"bundle_id", jni::ToNativeString(env, appId)}},
+                                   nullptr);
 }
 
-JNIEXPORT jlongArray JNICALL
+JNIEXPORT jlongArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetStats(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetStats(JNIEnv * env, jclass clazz)
 {
   auto const stats = Editor::Instance().GetStats();
   jlongArray result = env->NewLongArray(3);
@@ -352,14 +329,12 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetStats(JNIEnv * env, jclass clazz
   return result;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeClearLocalEdits(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeClearLocalEdits(JNIEnv * env, jclass clazz)
 {
   Editor::Instance().ClearAllLocalEdits();
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeStartEdit(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_editor_Editor_nativeStartEdit(JNIEnv *, jclass)
 {
   ::Framework * frm = g_framework->NativeFramework();
   if (!frm->HasPlacePageInfo())
@@ -373,8 +348,7 @@ Java_app_organicmaps_sdk_editor_Editor_nativeStartEdit(JNIEnv *, jclass)
   CHECK(frm->GetEditableMapObject(info.GetID(), g_editableMapObject), ("Invalid feature in the place page."));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeCreateMapObject(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_Editor_nativeCreateMapObject(JNIEnv * env, jclass,
                                                                                     jstring featureType)
 {
   ::Framework * frm = g_framework->NativeFramework();
@@ -384,11 +358,10 @@ Java_app_organicmaps_sdk_editor_Editor_nativeCreateMapObject(JNIEnv * env, jclas
 }
 
 // static void nativeCreateNote(String text);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeCreateNote(JNIEnv * env, jclass clazz, jstring text)
-Java_app_organicmaps_sdk_editor_Editor_nativeCreateNote(JNIEnv * env, jclass clazz, jstring text)
 {
-  g_framework->NativeFramework()->CreateNote(
+  g_framework->NativeFramework()->CreateNote(g_editableMapObject, osm::Editor::NoteProblemType::General,
-      g_editableMapObject, osm::Editor::NoteProblemType::General, jni::ToNativeString(env, text));
+                                             jni::ToNativeString(env, text));
 }
 
 JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeCreateStandaloneNote(JNIEnv * env, jclass clazz,
@@ -399,22 +372,20 @@ JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeCreateStanda
 }
 
 // static void nativePlaceDoesNotExist(String comment);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativePlaceDoesNotExist(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_Editor_nativePlaceDoesNotExist(JNIEnv * env, jclass clazz, jstring comment)
+                                                                                      jstring comment)
 {
-  g_framework->NativeFramework()->CreateNote(g_editableMapObject,
+  g_framework->NativeFramework()->CreateNote(g_editableMapObject, osm::Editor::NoteProblemType::PlaceDoesNotExist,
-                                             osm::Editor::NoteProblemType::PlaceDoesNotExist,
                                              jni::ToNativeString(env, comment));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeRollbackMapObject(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeRollbackMapObject(JNIEnv * env, jclass clazz)
 {
   g_framework->NativeFramework()->RollBackChanges(g_editableMapObject.GetID());
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetAllCreatableFeatureTypes(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_Editor_nativeGetAllCreatableFeatureTypes(JNIEnv * env, jclass clazz,
+                                                                                                        jclass clazz,
                                                                                                         jstring jLang)
 {
   std::string const & lang = jni::ToNativeString(env, jLang);
@@ -424,8 +395,8 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetAllCreatableFeatureTypes(JNIEnv
   return jni::ToJavaStringArray(env, categories.GetAllCreatableTypeNames());
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSearchCreatableFeatureTypes(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_Editor_nativeSearchCreatableFeatureTypes(JNIEnv * env, jclass clazz,
+                                                                                                        jclass clazz,
                                                                                                         jstring query,
                                                                                                         jstring jLang)
 {
@@ -436,8 +407,7 @@ Java_app_organicmaps_sdk_editor_Editor_nativeSearchCreatableFeatureTypes(JNIEnv
   return jni::ToJavaStringArray(env, categories.Search(jni::ToNativeString(env, query)));
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetCuisines(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetCuisines(JNIEnv * env, jclass clazz)
 {
   osm::AllCuisines const & cuisines = osm::Cuisines::Instance().AllSupportedCuisines();
   std::vector<std::string> keys;
@@ -447,14 +417,15 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetCuisines(JNIEnv * env, jclass cl
   return jni::ToJavaStringArray(env, keys);
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetSelectedCuisines(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_Editor_nativeGetSelectedCuisines(JNIEnv * env, jclass clazz)
+                                                                                                jclass clazz)
 {
   return jni::ToJavaStringArray(env, g_editableMapObject.GetCuisines());
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeFilterCuisinesKeys(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_Editor_nativeFilterCuisinesKeys(JNIEnv * env, jclass thiz, jstring jSubstr)
+                                                                                               jclass thiz,
+                                                                                               jstring jSubstr)
 {
   std::string const substr = jni::ToNativeString(env, jSubstr);
   bool const noFilter = substr.length() == 0;
@@ -473,8 +444,9 @@ Java_app_organicmaps_sdk_editor_Editor_nativeFilterCuisinesKeys(JNIEnv * env, jc
   return jni::ToJavaStringArray(env, keys);
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeTranslateCuisines(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_Editor_nativeTranslateCuisines(JNIEnv * env, jclass clazz, jobjectArray jKeys)
+                                                                                              jclass clazz,
+                                                                                              jobjectArray jKeys)
 {
   int const length = env->GetArrayLength(jKeys);
   auto const & cuisines = osm::Cuisines::Instance();
@@ -488,8 +460,8 @@ Java_app_organicmaps_sdk_editor_Editor_nativeTranslateCuisines(JNIEnv * env, jcl
   return jni::ToJavaStringArray(env, translations);
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeSetSelectedCuisines(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_Editor_nativeSetSelectedCuisines(JNIEnv * env, jclass clazz, jobjectArray jKeys)
+                                                                                        jobjectArray jKeys)
 {
   int const length = env->GetArrayLength(jKeys);
   std::vector<std::string> cuisines;
@@ -499,39 +471,35 @@ Java_app_organicmaps_sdk_editor_Editor_nativeSetSelectedCuisines(JNIEnv * env, j
   g_editableMapObject.SetCuisines(cuisines);
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetFormattedCuisine(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetFormattedCuisine(JNIEnv * env, jclass clazz)
 {
   return jni::ToJavaString(env, g_editableMapObject.FormatCuisines());
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetMwmName(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetMwmName(JNIEnv * env, jclass clazz)
 {
   return jni::ToJavaString(env, g_editableMapObject.GetID().GetMwmName());
 }
 
-JNIEXPORT jlong JNICALL
+JNIEXPORT jlong JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetMwmVersion(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetMwmVersion(JNIEnv * env, jclass clazz)
 {
   return g_editableMapObject.GetID().GetMwmVersion();
 }
 
 // static boolean nativeIsHouseValid(String houseNumber);
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsHouseValid(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_Editor_nativeIsHouseValid(JNIEnv * env, jclass clazz, jstring houseNumber)
+                                                                                     jstring houseNumber)
 {
   return osm::EditableMapObject::ValidateHouseNumber(jni::ToNativeString(env, houseNumber));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsNameValid(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_Editor_nativeIsNameValid(JNIEnv * env, jclass clazz, jstring name)
+                                                                                    jstring name)
 {
   return osm::EditableMapObject::ValidateName(jni::ToNativeString(env, name));
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetCategory(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetCategory(JNIEnv * env, jclass clazz)
 {
   auto types = g_editableMapObject.GetTypes();
   types.SortBySpec();
@@ -540,21 +508,20 @@ Java_app_organicmaps_sdk_editor_Editor_nativeGetCategory(JNIEnv * env, jclass cl
 
 // @FeatureStatus
 // static native int nativeGetMapObjectStatus();
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeGetMapObjectStatus(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeGetMapObjectStatus(JNIEnv * env, jclass clazz)
 {
   return static_cast<jint>(osm::Editor::Instance().GetFeatureStatus(g_editableMapObject.GetID()));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeIsMapObjectUploaded(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_Editor_nativeIsMapObjectUploaded(JNIEnv * env, jclass clazz)
 {
-  return osm::Editor::Instance().IsFeatureUploaded(g_editableMapObject.GetID().m_mwmId, g_editableMapObject.GetID().m_index);
+  return osm::Editor::Instance().IsFeatureUploaded(g_editableMapObject.GetID().m_mwmId,
+                                                   g_editableMapObject.GetID().m_index);
 }
 
 // static nativeMakeLocalizedName(String langCode, String name);
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_Editor_nativeMakeLocalizedName(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_Editor_nativeMakeLocalizedName(JNIEnv * env, jclass clazz, jstring code, jstring name)
+                                                                                         jstring code, jstring name)
 {
   osm::LocalizedName localizedName(jni::ToNativeString(env, code), jni::ToNativeString(env, name));
   return ToJavaName(env, localizedName);

android/sdk/src/main/cpp/app/organicmaps/sdk/editor/OpeningHours.cpp

@@ -14,7 +14,6 @@
 #include <set>
 #include <vector>
 
-
 namespace
 {
 using namespace editor;
@@ -43,22 +42,12 @@ jfieldID g_fidWeekdays;
 
 jobject JavaHoursMinutes(JNIEnv * env, jlong hours, jlong minutes)
 {
-  static const jclass dateUtilsClass = jni::GetGlobalClassRef(env,
+  static jclass const dateUtilsClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/util/DateUtils");
-                                                              "app/organicmaps/sdk/util/DateUtils");
   static jmethodID const is24HourFormatMethod =
-    jni::GetStaticMethodID(env,
+      jni::GetStaticMethodID(env, dateUtilsClass, "is24HourFormat", "(Landroid/content/Context;)Z");
-                           dateUtilsClass,
-                           "is24HourFormat",
-                           "(Landroid/content/Context;)Z");
   jobject context = android::Platform::Instance().GetContext();
-  jboolean const is24HourFormat = env->CallStaticBooleanMethod(dateUtilsClass,
+  jboolean const is24HourFormat = env->CallStaticBooleanMethod(dateUtilsClass, is24HourFormatMethod, context);
-                                                               is24HourFormatMethod,
+  jobject const hoursMinutes = env->NewObject(g_clazzHoursMinutes, g_ctorHoursMinutes, hours, minutes, is24HourFormat);
-                                                               context);
-  jobject const hoursMinutes = env->NewObject(g_clazzHoursMinutes,
-                                              g_ctorHoursMinutes,
-                                              hours,
-                                              minutes,
-                                              is24HourFormat);
   ASSERT(hoursMinutes, (jni::DescribeException()));
   return hoursMinutes;
 }
@@ -74,8 +63,7 @@ jobject JavaTimespan(JNIEnv * env, osmoh::Timespan const & timespan)
 {
   auto const start = timespan.GetStart();
   auto const end = timespan.GetEnd();
-  return JavaTimespan(env,
+  return JavaTimespan(env, JavaHoursMinutes(env, start.GetHoursCount(), start.GetMinutesCount()),
-                      JavaHoursMinutes(env, start.GetHoursCount(), start.GetMinutesCount()),
                       JavaHoursMinutes(env, end.GetHoursCount(), end.GetMinutesCount()));
 }
 
@@ -92,22 +80,16 @@ jobject JavaTimetable(JNIEnv * env, TimeTable const & tt)
   std::set<Weekday> weekdays = tt.GetOpeningDays();
   std::vector<int> weekdaysVector;
   weekdaysVector.reserve(weekdays.size());
-  std::transform(weekdays.begin(), weekdays.end(), std::back_inserter(weekdaysVector), [](Weekday weekday)
+  std::transform(weekdays.begin(), weekdays.end(), std::back_inserter(weekdaysVector),
-  {
+                 [](Weekday weekday) { return static_cast<int>(weekday); });
-    return static_cast<int>(weekday);
-  });
   jintArray jWeekdays = env->NewIntArray(static_cast<jsize>(weekdays.size()));
-  env->SetIntArrayRegion(jWeekdays, 0, static_cast<jsize>(weekdaysVector.size()),
+  env->SetIntArrayRegion(jWeekdays, 0, static_cast<jsize>(weekdaysVector.size()), &weekdaysVector[0]);
-                         &weekdaysVector[0]);
 
-  return JavaTimetable(env,
+  return JavaTimetable(
-                       JavaTimespan(env, tt.GetOpeningTime()),
+      env, JavaTimespan(env, tt.GetOpeningTime()),
-                       jni::ToJavaArray(env, g_clazzTimespan, tt.GetExcludeTime(), [](JNIEnv * env, osmoh::Timespan const & timespan)
+      jni::ToJavaArray(env, g_clazzTimespan, tt.GetExcludeTime(),
-                       {
+                       [](JNIEnv * env, osmoh::Timespan const & timespan) { return JavaTimespan(env, timespan); }),
-                         return JavaTimespan(env, timespan);
+      tt.IsTwentyFourHours(), jWeekdays);
-                       }),
-                       tt.IsTwentyFourHours(),
-                       jWeekdays);
 }
 
 jobjectArray JavaTimetables(JNIEnv * env, TimeTableSet & tts)
@@ -142,7 +124,7 @@ TimeTable NativeTimetable(JNIEnv * env, jobject jTimetable)
 {
   TimeTable tt = TimeTable::GetPredefinedTimeTable();
   jintArray const jWeekdays = static_cast<jintArray>(env->GetObjectField(jTimetable, g_fidWeekdays));
-  int * weekdaysArr = static_cast<int*>(env->GetIntArrayElements(jWeekdays, nullptr));
+  int * weekdaysArr = static_cast<int *>(env->GetIntArrayElements(jWeekdays, nullptr));
   jint size = env->GetArrayLength(jWeekdays);
   std::set<Weekday> weekdays;
   for (int i = 0; i < size; i++)
@@ -181,8 +163,7 @@ TimeTableSet NativeTimetableSet(JNIEnv * env, jobjectArray jTimetables)
 
 extern "C"
 {
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeInit(JNIEnv * env, jclass clazz)
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeInit(JNIEnv * env, jclass clazz)
 {
   g_clazzHoursMinutes = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/editor/data/HoursMinutes");
   // Java signature : HoursMinutes(@IntRange(from = 0, to = 24) long hours, @IntRange(from = 0, to = 60) long minutes)
@@ -195,8 +176,9 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeInit(JNIEnv * env, jclass cla
 
   g_clazzTimespan = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/editor/data/Timespan");
   // Java signature : Timespan(HoursMinutes start, HoursMinutes end)
-  g_ctorTimespan =
+  g_ctorTimespan = env->GetMethodID(
-      env->GetMethodID(g_clazzTimespan, "<init>","(Lapp/organicmaps/sdk/editor/data/HoursMinutes;Lapp/organicmaps/sdk/editor/data/HoursMinutes;)V");
+      g_clazzTimespan, "<init>",
+      "(Lapp/organicmaps/sdk/editor/data/HoursMinutes;Lapp/organicmaps/sdk/editor/data/HoursMinutes;)V");
   ASSERT(g_ctorTimespan, (jni::DescribeException()));
   g_fidStart = env->GetFieldID(g_clazzTimespan, "start", "Lapp/organicmaps/sdk/editor/data/HoursMinutes;");
   ASSERT(g_fidStart, (jni::DescribeException()));
@@ -206,11 +188,14 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeInit(JNIEnv * env, jclass cla
   g_clazzTimetable = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/editor/data/Timetable");
   // Java signature : Timetable(Timespan workingTime, Timespan[] closedHours, boolean isFullday, int weekdays[])
   g_ctorTimetable =
-      env->GetMethodID(g_clazzTimetable, "<init>","(Lapp/organicmaps/sdk/editor/data/Timespan;[Lapp/organicmaps/sdk/editor/data/Timespan;Z[I)V");
+      env->GetMethodID(g_clazzTimetable, "<init>",
+                       "(Lapp/organicmaps/sdk/editor/data/Timespan;[Lapp/organicmaps/sdk/editor/data/Timespan;Z[I)V");
   ASSERT(g_ctorTimetable, (jni::DescribeException()));
-  g_fidWorkingTimespan = env->GetFieldID(g_clazzTimetable, "workingTimespan", "Lapp/organicmaps/sdk/editor/data/Timespan;");
+  g_fidWorkingTimespan =
+      env->GetFieldID(g_clazzTimetable, "workingTimespan", "Lapp/organicmaps/sdk/editor/data/Timespan;");
   ASSERT(g_fidWorkingTimespan, (jni::DescribeException()));
-  g_fidClosedTimespans = env->GetFieldID(g_clazzTimetable, "closedTimespans", "[Lapp/organicmaps/sdk/editor/data/Timespan;");
+  g_fidClosedTimespans =
+      env->GetFieldID(g_clazzTimetable, "closedTimespans", "[Lapp/organicmaps/sdk/editor/data/Timespan;");
   ASSERT(g_fidClosedTimespans, (jni::DescribeException()));
   g_fidIsFullday = env->GetFieldID(g_clazzTimetable, "isFullday", "Z");
   ASSERT(g_fidIsFullday, (jni::DescribeException()));
@@ -218,23 +203,22 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeInit(JNIEnv * env, jclass cla
   ASSERT(g_fidWeekdays, (jni::DescribeException()));
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeGetDefaultTimetables(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeGetDefaultTimetables(JNIEnv * env, jclass clazz)
+                                                                                                       jclass clazz)
 {
   TimeTableSet tts;
   return JavaTimetables(env, tts);
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeGetComplementTimetable(
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeGetComplementTimetable(JNIEnv * env, jclass clazz, jobjectArray timetables)
+    JNIEnv * env, jclass clazz, jobjectArray timetables)
 {
   TimeTableSet const tts = NativeTimetableSet(env, timetables);
   return JavaTimetable(env, tts.GetComplementTimeTable());
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeRemoveWorkingDay(
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeRemoveWorkingDay(JNIEnv * env, jclass clazz,
+    JNIEnv * env, jclass clazz, jobjectArray timetables, jint ttIndex, jint dayIndex)
-                                                                jobjectArray timetables, jint ttIndex, jint dayIndex)
 {
   TimeTableSet tts = NativeTimetableSet(env, timetables);
   auto tt = tts.Get(ttIndex);
@@ -243,9 +227,8 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeRemoveWorkingDay(JNIEnv * env
   return JavaTimetables(env, tts);
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeAddWorkingDay(
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeAddWorkingDay(JNIEnv * env, jclass clazz,
+    JNIEnv * env, jclass clazz, jobjectArray timetables, jint ttIndex, jint dayIndex)
-                                                             jobjectArray timetables, jint ttIndex, jint dayIndex)
 {
   TimeTableSet tts = NativeTimetableSet(env, timetables);
   auto tt = tts.Get(ttIndex);
@@ -254,9 +237,9 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeAddWorkingDay(JNIEnv * env, j
   return JavaTimetables(env, tts);
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeSetIsFullday(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeSetIsFullday(JNIEnv * env, jclass clazz,
+                                                                                          jobject jTimetable,
-                                                            jobject jTimetable, jboolean jIsFullday)
+                                                                                          jboolean jIsFullday)
 {
   TimeTable tt = NativeTimetable(env, jTimetable);
   if (jIsFullday)
@@ -269,35 +252,37 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeSetIsFullday(JNIEnv * env, jc
   return JavaTimetable(env, tt);
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeSetOpeningTime(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeSetOpeningTime(JNIEnv * env, jclass clazz,
+                                                                                            jobject jTimetable,
-                                                              jobject jTimetable, jobject jOpeningTime)
+                                                                                            jobject jOpeningTime)
 {
   TimeTable tt = NativeTimetable(env, jTimetable);
   tt.SetOpeningTime(NativeTimespan(env, jOpeningTime));
   return JavaTimetable(env, tt);
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeAddClosedSpan(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeAddClosedSpan(JNIEnv * env, jclass clazz,
+                                                                                           jobject jTimetable,
-                                                             jobject jTimetable, jobject jClosedSpan)
+                                                                                           jobject jClosedSpan)
 {
   TimeTable tt = NativeTimetable(env, jTimetable);
   tt.AddExcludeTime(NativeTimespan(env, jClosedSpan));
   return JavaTimetable(env, tt);
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeRemoveClosedSpan(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeRemoveClosedSpan(JNIEnv * env, jclass clazz,
+                                                                                              jclass clazz,
-                                                                jobject jTimetable, jint jClosedSpanIndex)
+                                                                                              jobject jTimetable,
+                                                                                              jint jClosedSpanIndex)
 {
   TimeTable tt = NativeTimetable(env, jTimetable);
   tt.RemoveExcludeTime(static_cast<size_t>(jClosedSpanIndex));
   return JavaTimetable(env, tt);
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeTimetablesFromString(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeTimetablesFromString(JNIEnv * env, jclass clazz, jstring jSource)
+                                                                                                       jclass clazz,
+                                                                                                       jstring jSource)
 {
   TimeTableSet tts;
   std::string const source = jni::ToNativeString(env, jSource);
@@ -307,8 +292,9 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeTimetablesFromString(JNIEnv *
   return nullptr;
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeTimetablesToString(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeTimetablesToString(JNIEnv * env, jclass clazz, jobjectArray jTts)
+                                                                                                jclass clazz,
+                                                                                                jobjectArray jTts)
 {
   TimeTableSet tts = NativeTimetableSet(env, jTts);
   std::stringstream sstr;
@@ -316,15 +302,15 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeTimetablesToString(JNIEnv * e
   return jni::ToJavaString(env, sstr.str());
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeIsTimetableStringValid(JNIEnv * env,
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeIsTimetableStringValid(JNIEnv * env, jclass clazz, jstring jSource)
+                                                                                                     jclass clazz,
+                                                                                                     jstring jSource)
 {
   return OpeningHours(jni::ToNativeString(env, jSource)).IsValid();
 }
 
-
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_editor_OpeningHours_nativeCurrentState(JNIEnv * env, jclass clazz,
-JNIEXPORT jobject JNICALL
+                                                                                          jobjectArray jTts)
-Java_app_organicmaps_sdk_editor_OpeningHours_nativeCurrentState(JNIEnv * env, jclass clazz, jobjectArray jTts)
 {
   TimeTableSet tts = NativeTimetableSet(env, jTts);
   time_t const now = time(nullptr);
@@ -334,16 +320,15 @@ Java_app_organicmaps_sdk_editor_OpeningHours_nativeCurrentState(JNIEnv * env, jc
   jclass ohStateClass = jni::GetGlobalClassRef(env, "app/organicmaps/editor/OhState");
   jclass ruleStateClass = jni::GetGlobalClassRef(env, "app/organicmaps/editor/OhState$State");
 
-  static const std::unordered_map<RuleState, const char*> ruleState = {
+  static std::unordered_map<RuleState, char const *> const ruleState = {
-      {RuleState::Open, "Open"},
+      {RuleState::Open, "Open"}, {RuleState::Closed, "Closed"}, {RuleState::Unknown, "Unknown"}};
-      {RuleState::Closed, "Closed"},
-      {RuleState::Unknown, "Unknown"}
-  };
 
-  jfieldID stateField = env->GetStaticFieldID(ruleStateClass, ruleState.at(ohInfo.state), "Lapp/organicmaps/editor/OhState$State;");
+  jfieldID stateField =
+      env->GetStaticFieldID(ruleStateClass, ruleState.at(ohInfo.state), "Lapp/organicmaps/editor/OhState$State;");
   jobject stateObj = env->GetStaticObjectField(ruleStateClass, stateField);
   jmethodID constructor = env->GetMethodID(ohStateClass, "<init>", "(Lapp/organicmaps/editor/OhState$State;JJ)V");
-  jobject javaOhState = env->NewObject(ohStateClass, constructor, stateObj, (jlong) ohInfo.nextTimeOpen, (jlong) ohInfo.nextTimeClosed);
+  jobject javaOhState =
+      env->NewObject(ohStateClass, constructor, stateObj, (jlong)ohInfo.nextTimeOpen, (jlong)ohInfo.nextTimeClosed);
 
   return javaOhState;
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/editor/OsmOAuth.cpp

@@ -1,7 +1,7 @@
 #include <jni.h>
 
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/Framework.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 
 #include "base/logging.hpp"
 #include "base/string_utils.hpp"
@@ -25,17 +25,15 @@ bool LoadOsmUserPreferences(std::string const & oauthToken, UserPreferences & ou
 
 extern "C"
 {
-
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOAuth2Url(JNIEnv * env, jclass)
-JNIEXPORT jstring JNICALL
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOAuth2Url(JNIEnv * env, jclass)
 {
   auto const auth = OsmOAuth::ServerAuth();
   return ToJavaString(env, auth.BuildOAuth2Url());
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeAuthWithPassword(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeAuthWithPassword(JNIEnv * env, jclass clazz,
+                                                                                          jstring login,
-                                                                jstring login, jstring password)
+                                                                                          jstring password)
 {
   OsmOAuth auth = OsmOAuth::ServerAuth();
   try
@@ -51,8 +49,8 @@ Java_app_organicmaps_sdk_editor_OsmOAuth_nativeAuthWithPassword(JNIEnv * env, jc
   return nullptr;
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeAuthWithOAuth2Code(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeAuthWithOAuth2Code(JNIEnv * env, jclass, jstring oauth2code)
+                                                                                            jstring oauth2code)
 {
   OsmOAuth auth = OsmOAuth::ServerAuth();
   try
@@ -72,8 +70,8 @@ Java_app_organicmaps_sdk_editor_OsmOAuth_nativeAuthWithOAuth2Code(JNIEnv * env,
   return nullptr;
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmUsername(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmUsername(JNIEnv * env, jclass, jstring oauthToken)
+                                                                                        jstring oauthToken)
 {
   UserPreferences prefs;
   if (LoadOsmUserPreferences(jni::ToNativeString(env, oauthToken), prefs))
@@ -81,8 +79,8 @@ Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmUsername(JNIEnv * env, jcla
   return nullptr;
 }
 
-JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmChangesetsCount(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmChangesetsCount(JNIEnv * env, jclass, jstring oauthToken)
+                                                                                            jstring oauthToken)
 {
   UserPreferences prefs;
   if (LoadOsmUserPreferences(jni::ToNativeString(env, oauthToken), prefs))
@@ -90,8 +88,8 @@ Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmChangesetsCount(JNIEnv * en
   return -1;
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmProfilePictureUrl(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmProfilePictureUrl(JNIEnv * env, jclass, jstring oauthToken)
+                                                                                                 jstring oauthToken)
 {
   UserPreferences prefs;
   if (LoadOsmUserPreferences(jni::ToNativeString(env, oauthToken), prefs))
@@ -99,14 +97,13 @@ Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetOsmProfilePictureUrl(JNIEnv *
   return nullptr;
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetHistoryUrl(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetHistoryUrl(JNIEnv * env, jclass, jstring user)
+                                                                                       jstring user)
 {
   return jni::ToJavaString(env, OsmOAuth::ServerAuth().GetHistoryURL(jni::ToNativeString(env, user)));
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetNotesUrl(JNIEnv * env, jclass, jstring user)
-Java_app_organicmaps_sdk_editor_OsmOAuth_nativeGetNotesUrl(JNIEnv * env, jclass, jstring user)
 {
   return jni::ToJavaString(env, OsmOAuth::ServerAuth().GetNotesURL(jni::ToNativeString(env, user)));
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/isolines/IsolinesManager.cpp

@@ -7,39 +7,34 @@ using namespace std::placeholders;
 
 extern "C"
 {
-static void IsolinesStateChanged(IsolinesManager::IsolinesState state,
+static void IsolinesStateChanged(IsolinesManager::IsolinesState state, std::shared_ptr<jobject> const & listener)
-                                 std::shared_ptr<jobject> const & listener)
 {
   LOG(LINFO, (static_cast<int>(state)));
   JNIEnv * env = jni::GetEnv();
-  env->CallVoidMethod(*listener,
+  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener, "onStateChanged", "(I)V"), static_cast<jint>(state));
-                      jni::GetMethodID(env, *listener, "onStateChanged", "(I)V"),
-                      static_cast<jint>(state));
 }
 
-
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_isolines_IsolinesManager_nativeAddListener(JNIEnv * env,
-JNIEXPORT void JNICALL
+                                                                                                    jclass clazz,
-Java_app_organicmaps_sdk_maplayer_isolines_IsolinesManager_nativeAddListener(JNIEnv *env, jclass clazz, jobject listener)
+                                                                                                    jobject listener)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
-  g_framework->SetIsolinesListener(std::bind(&IsolinesStateChanged,
+  g_framework->SetIsolinesListener(
-                                   std::placeholders::_1,
+      std::bind(&IsolinesStateChanged, std::placeholders::_1, jni::make_global_ref(listener)));
-                                   jni::make_global_ref(listener)));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_isolines_IsolinesManager_nativeRemoveListener(JNIEnv * env,
-Java_app_organicmaps_sdk_maplayer_isolines_IsolinesManager_nativeRemoveListener(JNIEnv * env, jclass clazz)
+                                                                                                       jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
   g_framework->SetIsolinesListener(nullptr);
 }
 
 JNIEXPORT jboolean JNICALL
-Java_app_organicmaps_sdk_maplayer_isolines_IsolinesManager_nativeShouldShowNotification(JNIEnv *env,
+Java_app_organicmaps_sdk_maplayer_isolines_IsolinesManager_nativeShouldShowNotification(JNIEnv * env, jclass clazz)
-        jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
-  auto const &manager = g_framework->NativeFramework()->GetIsolinesManager();
+  auto const & manager = g_framework->NativeFramework()->GetIsolinesManager();
   auto const visible = manager.IsVisible();
   auto const enabled = manager.GetState() == IsolinesManager::IsolinesState::Enabled;
   return static_cast<jboolean>(!visible && enabled);

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/android_gl_utils.cpp

@@ -7,10 +7,7 @@
 namespace android
 {
 
-ConfigComparator::ConfigComparator(EGLDisplay display)
+ConfigComparator::ConfigComparator(EGLDisplay display) : m_display(display) {}
-  : m_display(display)
-{
-}
 
 bool ConfigComparator::operator()(EGLConfig const & l, EGLConfig const & r) const
 {
@@ -28,14 +25,10 @@ int ConfigComparator::configWeight(EGLConfig const & config) const
 
   switch (val)
   {
-    case EGL_NONE:
+  case EGL_NONE: return 0;
-      return 0;
+  case EGL_SLOW_CONFIG: return 1;
-    case EGL_SLOW_CONFIG:
+  case EGL_NON_CONFORMANT_CONFIG: return 2;
-      return 1;
+  default: return 0;
-    case EGL_NON_CONFORMANT_CONFIG:
-      return 2;
-    default:
-      return 0;
   }
 }
 
@@ -53,20 +46,20 @@ std::string GetEglError(EGLint error)
 {
   switch (error)
   {
-  case EGL_NOT_INITIALIZED :      return "EGL_NOT_INITIALIZED";
+  case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
-  case EGL_BAD_ACCESS :           return "EGL_BAD_ACCESS";
+  case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
-  case EGL_BAD_ALLOC :            return "EGL_BAD_ALLOC";
+  case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
-  case EGL_BAD_ATTRIBUTE :        return "EGL_BAD_ATTRIBUTE";
+  case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
-  case EGL_BAD_CONFIG :           return "EGL_BAD_CONFIG";
+  case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
-  case EGL_BAD_CONTEXT :          return "EGL_BAD_CONTEXT";
+  case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
-  case EGL_BAD_CURRENT_SURFACE :  return "EGL_BAD_CURRENT_SURFACE";
+  case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
-  case EGL_BAD_DISPLAY :          return "EGL_BAD_DISPLAY";
+  case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
-  case EGL_BAD_MATCH :            return "EGL_BAD_MATCH";
+  case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
-  case EGL_BAD_NATIVE_PIXMAP :    return "EGL_BAD_NATIVE_PIXMAP";
+  case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
-  case EGL_BAD_NATIVE_WINDOW :    return "EGL_BAD_NATIVE_WINDOW";
+  case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
-  case EGL_BAD_PARAMETER :        return "EGL_BAD_PARAMETER";
+  case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
-  case EGL_BAD_SURFACE :          return "EGL_BAD_SURFACE";
+  case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE";
-  case EGL_CONTEXT_LOST :         return "EGL_CONTEXT_LOST";
+  case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
   default: return strings::to_string(error);
   }
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/android_gl_utils.hpp

@@ -25,5 +25,16 @@ private:
 void CheckEGL(base::SrcPoint const & src);
 }  // namespace android
 
-#define CHECK_EGL(x) do { (x); android::CheckEGL(SRC());} while(false);
+#define CHECK_EGL(x)          \
-#define CHECK_EGL_CALL() do { android::CheckEGL(SRC());} while (false);
+  do                          \
+  {                           \
+    (x);                      \
+    android::CheckEGL(SRC()); \
+  }                           \
+  while (false);
+#define CHECK_EGL_CALL()      \
+  do                          \
+  {                           \
+    android::CheckEGL(SRC()); \
+  }                           \
+  while (false);

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/androidoglcontext.cpp

@@ -10,15 +10,12 @@ namespace android
 
 static EGLint * getContextAttributesList()
 {
-  static EGLint contextAttrList[] = {
+  static EGLint contextAttrList[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
-    EGL_CONTEXT_CLIENT_VERSION, 3,
-    EGL_NONE
-  };
   return contextAttrList;
 }
 
-AndroidOGLContext::AndroidOGLContext(EGLDisplay display, EGLSurface surface,
+AndroidOGLContext::AndroidOGLContext(EGLDisplay display, EGLSurface surface, EGLConfig config,
-                                     EGLConfig config, AndroidOGLContext * contextToShareWith)
+                                     AndroidOGLContext * contextToShareWith)
   : m_nativeContext(EGL_NO_CONTEXT)
   , m_surface(surface)
   , m_display(display)
@@ -82,8 +79,7 @@ bool AndroidOGLContext::Validate()
 {
   if (!m_presentAvailable)
     return false;
-  return eglGetCurrentDisplay() != EGL_NO_DISPLAY &&
+  return eglGetCurrentDisplay() != EGL_NO_DISPLAY && eglGetCurrentSurface(EGL_DRAW) != EGL_NO_SURFACE &&
-         eglGetCurrentSurface(EGL_DRAW) != EGL_NO_SURFACE &&
          eglGetCurrentContext() != EGL_NO_CONTEXT;
 }
 

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/androidoglcontext.hpp

@@ -10,8 +10,7 @@ namespace android
 class AndroidOGLContext : public dp::OGLContext
 {
 public:
-  AndroidOGLContext(EGLDisplay display, EGLSurface surface,
+  AndroidOGLContext(EGLDisplay display, EGLSurface surface, EGLConfig config, AndroidOGLContext * contextToShareWith);
-                    EGLConfig config, AndroidOGLContext * contextToShareWith);
   ~AndroidOGLContext();
 
   void MakeCurrent() override;

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/androidoglcontextfactory.cpp

@@ -22,17 +22,23 @@ namespace
 {
 static EGLint * getConfigAttributesListRGB8()
 {
-  static EGLint attr_list[] = {
+  static EGLint attr_list[] = {EGL_RED_SIZE,
-    EGL_RED_SIZE, 8,
+                               8,
-    EGL_GREEN_SIZE, 8,
+                               EGL_GREEN_SIZE,
-    EGL_BLUE_SIZE, 8,
+                               8,
-    EGL_ALPHA_SIZE, 0,
+                               EGL_BLUE_SIZE,
-    EGL_STENCIL_SIZE, 0,
+                               8,
-    EGL_DEPTH_SIZE, 16,
+                               EGL_ALPHA_SIZE,
-    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
+                               0,
-    EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
+                               EGL_STENCIL_SIZE,
-    EGL_NONE
+                               0,
-  };
+                               EGL_DEPTH_SIZE,
+                               16,
+                               EGL_RENDERABLE_TYPE,
+                               EGL_OPENGL_ES3_BIT,
+                               EGL_SURFACE_TYPE,
+                               EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
+                               EGL_NONE};
   return attr_list;
 }
 
@@ -42,8 +48,8 @@ bool IsSupportedRGB8(EGLDisplay display)
 {
   EGLConfig configs[kMaxConfigCount];
   int count = 0;
-  return eglChooseConfig(display, getConfigAttributesListRGB8(), configs,
+  return eglChooseConfig(display, getConfigAttributesListRGB8(), configs, kMaxConfigCount, &count) == EGL_TRUE &&
-                         kMaxConfigCount, &count) == EGL_TRUE && count != 0;
+         count != 0;
 }
 
 size_t constexpr kGLThreadsCount = 2;
@@ -189,8 +195,7 @@ int AndroidOGLContextFactory::GetHeight() const
 void AndroidOGLContextFactory::UpdateSurfaceSize(int w, int h)
 {
   ASSERT(IsValid(), ());
-  if ((m_surfaceWidth != w && m_surfaceWidth != h) ||
+  if ((m_surfaceWidth != w && m_surfaceWidth != h) || (m_surfaceHeight != w && m_surfaceHeight != h))
-      (m_surfaceHeight != w && m_surfaceHeight != h))
   {
     LOG(LINFO, ("Surface size changed and must be re-queried."));
     if (!QuerySurfaceSize())
@@ -231,10 +236,7 @@ dp::GraphicsContext * AndroidOGLContextFactory::GetDrawContext()
   ASSERT(IsValid(), ());
   ASSERT(m_windowSurface != EGL_NO_SURFACE, ());
   if (m_drawContext == nullptr)
-  {
+    m_drawContext = new AndroidOGLContext(m_display, m_windowSurface, m_config, m_uploadContext);
-    m_drawContext = new AndroidOGLContext(m_display, m_windowSurface,
-                                          m_config, m_uploadContext);
-  }
   return m_drawContext;
 }
 
@@ -243,10 +245,7 @@ dp::GraphicsContext * AndroidOGLContextFactory::GetResourcesUploadContext()
   ASSERT(IsValid(), ());
   ASSERT(m_pixelbufferSurface != EGL_NO_SURFACE, ());
   if (m_uploadContext == nullptr)
-  {
+    m_uploadContext = new AndroidOGLContext(m_display, m_pixelbufferSurface, m_config, m_drawContext);
-    m_uploadContext = new AndroidOGLContext(m_display, m_pixelbufferSurface,
-                                            m_config, m_drawContext);
-  }
   return m_uploadContext;
 }
 
@@ -288,8 +287,7 @@ bool AndroidOGLContextFactory::CreateWindowSurface()
 {
   EGLConfig configs[kMaxConfigCount];
   int count = 0;
-  if (eglChooseConfig(m_display, getConfigAttributesListRGB8(), configs,
+  if (eglChooseConfig(m_display, getConfigAttributesListRGB8(), configs, kMaxConfigCount, &count) == EGL_TRUE)
-                      kMaxConfigCount, &count) == EGL_TRUE)
   {
     CHECK(IsSupportedRGB8(m_display), ("RGB8 is not suported on this device"));
     LOG(LDEBUG, ("Backbuffer format: RGB8"));
@@ -309,7 +307,7 @@ bool AndroidOGLContextFactory::CreateWindowSurface()
     eglGetConfigAttrib(m_display, currentConfig, EGL_NATIVE_VISUAL_ID, &format);
     ANativeWindow_setBuffersGeometry(m_nativeWindow, 0, 0, format);
 
-    EGLint surfaceAttributes[] = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE };
+    EGLint surfaceAttributes[] = {EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE};
     m_windowSurface = eglCreateWindowSurface(m_display, currentConfig, m_nativeWindow, surfaceAttributes);
     if (m_windowSurface == EGL_NO_SURFACE)
       continue;
@@ -330,14 +328,10 @@ bool AndroidOGLContextFactory::CreateWindowSurface()
 
 bool AndroidOGLContextFactory::CreatePixelbufferSurface()
 {
-  //ASSERT(m_config != NULL, ());
+  // ASSERT(m_config != NULL, ());
 
-  const GLuint size = 1; // yes, 1 is the correct size, we dont really draw on it
+  GLuint const size = 1;  // yes, 1 is the correct size, we dont really draw on it
-  static EGLint surfaceConfig[] = {
+  static EGLint surfaceConfig[] = {EGL_WIDTH, size, EGL_HEIGHT, size, EGL_NONE};
-      EGL_WIDTH, size,
-      EGL_HEIGHT, size,
-      EGL_NONE
-  };
 
   m_pixelbufferSurface = eglCreatePbufferSurface(m_display, m_config, surfaceConfig);
 

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/androidoglcontextfactory.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "androidoglcontext.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "drape/graphics_context_factory.hpp"
 
 #include "base/src_point.hpp"

android/sdk/src/main/cpp/app/organicmaps/sdk/opengl/gl3stub.cpp

@@ -16,8 +16,9 @@
 
 #include "gl3stub.h"
 
-GLboolean gl3stubInit() {
+GLboolean gl3stubInit()
-    #define FIND_PROC(s) s = reinterpret_cast<decltype(s)>(eglGetProcAddress(#s))
+{
+#define FIND_PROC(s) s = reinterpret_cast<decltype(s)>(eglGetProcAddress(#s))
   FIND_PROC(glReadBuffer);
   FIND_PROC(glDrawRangeElements);
   FIND_PROC(glTexImage3D);
@@ -122,111 +123,31 @@ GLboolean gl3stubInit() {
   FIND_PROC(glTexStorage2D);
   FIND_PROC(glTexStorage3D);
   FIND_PROC(glGetInternalformativ);
-    #undef FIND_PROC
+#undef FIND_PROC
 
-    if (!glReadBuffer ||
+  if (!glReadBuffer || !glDrawRangeElements || !glTexImage3D || !glTexSubImage3D || !glCopyTexSubImage3D ||
-        !glDrawRangeElements ||
+      !glCompressedTexImage3D || !glCompressedTexSubImage3D || !glGenQueries || !glDeleteQueries || !glIsQuery ||
-        !glTexImage3D ||
+      !glBeginQuery || !glEndQuery || !glGetQueryiv || !glGetQueryObjectuiv || !glUnmapBuffer || !glGetBufferPointerv ||
-        !glTexSubImage3D ||
+      !glDrawBuffers || !glUniformMatrix2x3fv || !glUniformMatrix3x2fv || !glUniformMatrix2x4fv ||
-        !glCopyTexSubImage3D ||
+      !glUniformMatrix4x2fv || !glUniformMatrix3x4fv || !glUniformMatrix4x3fv || !glBlitFramebuffer ||
-        !glCompressedTexImage3D ||
+      !glRenderbufferStorageMultisample || !glFramebufferTextureLayer || !glMapBufferRange ||
-        !glCompressedTexSubImage3D ||
+      !glFlushMappedBufferRange || !glBindVertexArray || !glDeleteVertexArrays || !glGenVertexArrays ||
-        !glGenQueries ||
+      !glIsVertexArray || !glGetIntegeri_v || !glBeginTransformFeedback || !glEndTransformFeedback ||
-        !glDeleteQueries ||
+      !glBindBufferRange || !glBindBufferBase || !glTransformFeedbackVaryings || !glGetTransformFeedbackVarying ||
-        !glIsQuery ||
+      !glVertexAttribIPointer || !glGetVertexAttribIiv || !glGetVertexAttribIuiv || !glVertexAttribI4i ||
-        !glBeginQuery ||
+      !glVertexAttribI4ui || !glVertexAttribI4iv || !glVertexAttribI4uiv || !glGetUniformuiv ||
-        !glEndQuery ||
+      !glGetFragDataLocation || !glUniform1ui || !glUniform2ui || !glUniform3ui || !glUniform4ui || !glUniform1uiv ||
-        !glGetQueryiv ||
+      !glUniform2uiv || !glUniform3uiv || !glUniform4uiv || !glClearBufferiv || !glClearBufferuiv || !glClearBufferfv ||
-        !glGetQueryObjectuiv ||
+      !glClearBufferfi || !glGetStringi || !glCopyBufferSubData || !glGetUniformIndices || !glGetActiveUniformsiv ||
-        !glUnmapBuffer ||
+      !glGetUniformBlockIndex || !glGetActiveUniformBlockiv || !glGetActiveUniformBlockName || !glUniformBlockBinding ||
-        !glGetBufferPointerv ||
+      !glDrawArraysInstanced || !glDrawElementsInstanced || !glFenceSync || !glIsSync || !glDeleteSync ||
-        !glDrawBuffers ||
+      !glClientWaitSync || !glWaitSync || !glGetInteger64v || !glGetSynciv || !glGetInteger64i_v ||
-        !glUniformMatrix2x3fv ||
+      !glGetBufferParameteri64v || !glGenSamplers || !glDeleteSamplers || !glIsSampler || !glBindSampler ||
-        !glUniformMatrix3x2fv ||
+      !glSamplerParameteri || !glSamplerParameteriv || !glSamplerParameterf || !glSamplerParameterfv ||
-        !glUniformMatrix2x4fv ||
+      !glGetSamplerParameteriv || !glGetSamplerParameterfv || !glVertexAttribDivisor || !glBindTransformFeedback ||
-        !glUniformMatrix4x2fv ||
+      !glDeleteTransformFeedbacks || !glGenTransformFeedbacks || !glIsTransformFeedback || !glPauseTransformFeedback ||
-        !glUniformMatrix3x4fv ||
+      !glResumeTransformFeedback || !glGetProgramBinary || !glProgramBinary || !glProgramParameteri ||
-        !glUniformMatrix4x3fv ||
+      !glInvalidateFramebuffer || !glInvalidateSubFramebuffer || !glTexStorage2D || !glTexStorage3D ||
-        !glBlitFramebuffer ||
-        !glRenderbufferStorageMultisample ||
-        !glFramebufferTextureLayer ||
-        !glMapBufferRange ||
-        !glFlushMappedBufferRange ||
-        !glBindVertexArray ||
-        !glDeleteVertexArrays ||
-        !glGenVertexArrays ||
-        !glIsVertexArray ||
-        !glGetIntegeri_v ||
-        !glBeginTransformFeedback ||
-        !glEndTransformFeedback ||
-        !glBindBufferRange ||
-        !glBindBufferBase ||
-        !glTransformFeedbackVaryings ||
-        !glGetTransformFeedbackVarying ||
-        !glVertexAttribIPointer ||
-        !glGetVertexAttribIiv ||
-        !glGetVertexAttribIuiv ||
-        !glVertexAttribI4i ||
-        !glVertexAttribI4ui ||
-        !glVertexAttribI4iv ||
-        !glVertexAttribI4uiv ||
-        !glGetUniformuiv ||
-        !glGetFragDataLocation ||
-        !glUniform1ui ||
-        !glUniform2ui ||
-        !glUniform3ui ||
-        !glUniform4ui ||
-        !glUniform1uiv ||
-        !glUniform2uiv ||
-        !glUniform3uiv ||
-        !glUniform4uiv ||
-        !glClearBufferiv ||
-        !glClearBufferuiv ||
-        !glClearBufferfv ||
-        !glClearBufferfi ||
-        !glGetStringi ||
-        !glCopyBufferSubData ||
-        !glGetUniformIndices ||
-        !glGetActiveUniformsiv ||
-        !glGetUniformBlockIndex ||
-        !glGetActiveUniformBlockiv ||
-        !glGetActiveUniformBlockName ||
-        !glUniformBlockBinding ||
-        !glDrawArraysInstanced ||
-        !glDrawElementsInstanced ||
-        !glFenceSync ||
-        !glIsSync ||
-        !glDeleteSync ||
-        !glClientWaitSync ||
-        !glWaitSync ||
-        !glGetInteger64v ||
-        !glGetSynciv ||
-        !glGetInteger64i_v ||
-        !glGetBufferParameteri64v ||
-        !glGenSamplers ||
-        !glDeleteSamplers ||
-        !glIsSampler ||
-        !glBindSampler ||
-        !glSamplerParameteri ||
-        !glSamplerParameteriv ||
-        !glSamplerParameterf ||
-        !glSamplerParameterfv ||
-        !glGetSamplerParameteriv ||
-        !glGetSamplerParameterfv ||
-        !glVertexAttribDivisor ||
-        !glBindTransformFeedback ||
-        !glDeleteTransformFeedbacks ||
-        !glGenTransformFeedbacks ||
-        !glIsTransformFeedback ||
-        !glPauseTransformFeedback ||
-        !glResumeTransformFeedback ||
-        !glGetProgramBinary ||
-        !glProgramBinary ||
-        !glProgramParameteri ||
-        !glInvalidateFramebuffer ||
-        !glInvalidateSubFramebuffer ||
-        !glTexStorage2D ||
-        !glTexStorage3D ||
       !glGetInternalformativ)
   {
     return GL_FALSE;
@@ -236,107 +157,148 @@ GLboolean gl3stubInit() {
 }
 
 /* Function pointer definitions */
-GL_APICALL void           (* GL_APIENTRY glReadBuffer) (GLenum mode);
+GL_APICALL void (*GL_APIENTRY glReadBuffer)(GLenum mode);
-GL_APICALL void           (* GL_APIENTRY glDrawRangeElements) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices);
+GL_APICALL void (*GL_APIENTRY glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
-GL_APICALL void           (* GL_APIENTRY glTexImage3D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
+                                                   GLvoid const * indices);
-GL_APICALL void           (* GL_APIENTRY glTexSubImage3D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels);
+GL_APICALL void (*GL_APIENTRY glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width,
-GL_APICALL void           (* GL_APIENTRY glCopyTexSubImage3D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+                                            GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
-GL_APICALL void           (* GL_APIENTRY glCompressedTexImage3D) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data);
+                                            GLvoid const * pixels);
-GL_APICALL void           (* GL_APIENTRY glCompressedTexSubImage3D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data);
+GL_APICALL void (*GL_APIENTRY glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
-GL_APICALL void           (* GL_APIENTRY glGenQueries) (GLsizei n, GLuint* ids);
+                                               GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
-GL_APICALL void           (* GL_APIENTRY glDeleteQueries) (GLsizei n, const GLuint* ids);
+                                               GLvoid const * pixels);
-GL_APICALL GLboolean      (* GL_APIENTRY glIsQuery) (GLuint id);
+GL_APICALL void (*GL_APIENTRY glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-GL_APICALL void           (* GL_APIENTRY glBeginQuery) (GLenum target, GLuint id);
+                                                   GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-GL_APICALL void           (* GL_APIENTRY glEndQuery) (GLenum target);
+GL_APICALL void (*GL_APIENTRY glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width,
-GL_APICALL void           (* GL_APIENTRY glGetQueryiv) (GLenum target, GLenum pname, GLint* params);
+                                                      GLsizei height, GLsizei depth, GLint border, GLsizei imageSize,
-GL_APICALL void           (* GL_APIENTRY glGetQueryObjectuiv) (GLuint id, GLenum pname, GLuint* params);
+                                                      GLvoid const * data);
-GL_APICALL GLboolean      (* GL_APIENTRY glUnmapBuffer) (GLenum target);
+GL_APICALL void (*GL_APIENTRY glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-GL_APICALL void           (* GL_APIENTRY glGetBufferPointerv) (GLenum target, GLenum pname, GLvoid** params);
+                                                         GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
-GL_APICALL void           (* GL_APIENTRY glDrawBuffers) (GLsizei n, const GLenum* bufs);
+                                                         GLenum format, GLsizei imageSize, GLvoid const * data);
-GL_APICALL void           (* GL_APIENTRY glUniformMatrix2x3fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void (*GL_APIENTRY glGenQueries)(GLsizei n, GLuint * ids);
-GL_APICALL void           (* GL_APIENTRY glUniformMatrix3x2fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void (*GL_APIENTRY glDeleteQueries)(GLsizei n, GLuint const * ids);
-GL_APICALL void           (* GL_APIENTRY glUniformMatrix2x4fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL GLboolean (*GL_APIENTRY glIsQuery)(GLuint id);
-GL_APICALL void           (* GL_APIENTRY glUniformMatrix4x2fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void (*GL_APIENTRY glBeginQuery)(GLenum target, GLuint id);
-GL_APICALL void           (* GL_APIENTRY glUniformMatrix3x4fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void (*GL_APIENTRY glEndQuery)(GLenum target);
-GL_APICALL void           (* GL_APIENTRY glUniformMatrix4x3fv) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void (*GL_APIENTRY glGetQueryiv)(GLenum target, GLenum pname, GLint * params);
-GL_APICALL void           (* GL_APIENTRY glBlitFramebuffer) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+GL_APICALL void (*GL_APIENTRY glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params);
-GL_APICALL void           (* GL_APIENTRY glRenderbufferStorageMultisample) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+GL_APICALL GLboolean (*GL_APIENTRY glUnmapBuffer)(GLenum target);
-GL_APICALL void           (* GL_APIENTRY glFramebufferTextureLayer) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+GL_APICALL void (*GL_APIENTRY glGetBufferPointerv)(GLenum target, GLenum pname, GLvoid ** params);
-GL_APICALL GLvoid*        (* GL_APIENTRY glMapBufferRange) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+GL_APICALL void (*GL_APIENTRY glDrawBuffers)(GLsizei n, GLenum const * bufs);
-GL_APICALL void           (* GL_APIENTRY glFlushMappedBufferRange) (GLenum target, GLintptr offset, GLsizeiptr length);
+GL_APICALL void (*GL_APIENTRY glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose,
-GL_APICALL void           (* GL_APIENTRY glBindVertexArray) (GLuint array);
+                                                    GLfloat const * value);
-GL_APICALL void           (* GL_APIENTRY glDeleteVertexArrays) (GLsizei n, const GLuint* arrays);
+GL_APICALL void (*GL_APIENTRY glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose,
-GL_APICALL void           (* GL_APIENTRY glGenVertexArrays) (GLsizei n, GLuint* arrays);
+                                                    GLfloat const * value);
-GL_APICALL GLboolean      (* GL_APIENTRY glIsVertexArray) (GLuint array);
+GL_APICALL void (*GL_APIENTRY glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose,
-GL_APICALL void           (* GL_APIENTRY glGetIntegeri_v) (GLenum target, GLuint index, GLint* data);
+                                                    GLfloat const * value);
-GL_APICALL void           (* GL_APIENTRY glBeginTransformFeedback) (GLenum primitiveMode);
+GL_APICALL void (*GL_APIENTRY glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose,
-GL_APICALL void           (* GL_APIENTRY glEndTransformFeedback) (void);
+                                                    GLfloat const * value);
-GL_APICALL void           (* GL_APIENTRY glBindBufferRange) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+GL_APICALL void (*GL_APIENTRY glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose,
-GL_APICALL void           (* GL_APIENTRY glBindBufferBase) (GLenum target, GLuint index, GLuint buffer);
+                                                    GLfloat const * value);
-GL_APICALL void           (* GL_APIENTRY glTransformFeedbackVaryings) (GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode);
+GL_APICALL void (*GL_APIENTRY glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose,
-GL_APICALL void           (* GL_APIENTRY glGetTransformFeedbackVarying) (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name);
+                                                    GLfloat const * value);
-GL_APICALL void           (* GL_APIENTRY glVertexAttribIPointer) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
+GL_APICALL void (*GL_APIENTRY glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0,
-GL_APICALL void           (* GL_APIENTRY glGetVertexAttribIiv) (GLuint index, GLenum pname, GLint* params);
+                                                 GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-GL_APICALL void           (* GL_APIENTRY glGetVertexAttribIuiv) (GLuint index, GLenum pname, GLuint* params);
+GL_APICALL void (*GL_APIENTRY glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat,
-GL_APICALL void           (* GL_APIENTRY glVertexAttribI4i) (GLuint index, GLint x, GLint y, GLint z, GLint w);
+                                                                GLsizei width, GLsizei height);
-GL_APICALL void           (* GL_APIENTRY glVertexAttribI4ui) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+GL_APICALL void (*GL_APIENTRY glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level,
-GL_APICALL void           (* GL_APIENTRY glVertexAttribI4iv) (GLuint index, const GLint* v);
+                                                         GLint layer);
-GL_APICALL void           (* GL_APIENTRY glVertexAttribI4uiv) (GLuint index, const GLuint* v);
+GL_APICALL GLvoid * (*GL_APIENTRY glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length,
-GL_APICALL void           (* GL_APIENTRY glGetUniformuiv) (GLuint program, GLint location, GLuint* params);
+                                                    GLbitfield access);
-GL_APICALL GLint          (* GL_APIENTRY glGetFragDataLocation) (GLuint program, const GLchar *name);
+GL_APICALL void (*GL_APIENTRY glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
-GL_APICALL void           (* GL_APIENTRY glUniform1ui) (GLint location, GLuint v0);
+GL_APICALL void (*GL_APIENTRY glBindVertexArray)(GLuint array);
-GL_APICALL void           (* GL_APIENTRY glUniform2ui) (GLint location, GLuint v0, GLuint v1);
+GL_APICALL void (*GL_APIENTRY glDeleteVertexArrays)(GLsizei n, GLuint const * arrays);
-GL_APICALL void           (* GL_APIENTRY glUniform3ui) (GLint location, GLuint v0, GLuint v1, GLuint v2);
+GL_APICALL void (*GL_APIENTRY glGenVertexArrays)(GLsizei n, GLuint * arrays);
-GL_APICALL void           (* GL_APIENTRY glUniform4ui) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+GL_APICALL GLboolean (*GL_APIENTRY glIsVertexArray)(GLuint array);
-GL_APICALL void           (* GL_APIENTRY glUniform1uiv) (GLint location, GLsizei count, const GLuint* value);
+GL_APICALL void (*GL_APIENTRY glGetIntegeri_v)(GLenum target, GLuint index, GLint * data);
-GL_APICALL void           (* GL_APIENTRY glUniform2uiv) (GLint location, GLsizei count, const GLuint* value);
+GL_APICALL void (*GL_APIENTRY glBeginTransformFeedback)(GLenum primitiveMode);
-GL_APICALL void           (* GL_APIENTRY glUniform3uiv) (GLint location, GLsizei count, const GLuint* value);
+GL_APICALL void (*GL_APIENTRY glEndTransformFeedback)(void);
-GL_APICALL void           (* GL_APIENTRY glUniform4uiv) (GLint location, GLsizei count, const GLuint* value);
+GL_APICALL void (*GL_APIENTRY glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset,
-GL_APICALL void           (* GL_APIENTRY glClearBufferiv) (GLenum buffer, GLint drawbuffer, const GLint* value);
+                                                 GLsizeiptr size);
-GL_APICALL void           (* GL_APIENTRY glClearBufferuiv) (GLenum buffer, GLint drawbuffer, const GLuint* value);
+GL_APICALL void (*GL_APIENTRY glBindBufferBase)(GLenum target, GLuint index, GLuint buffer);
-GL_APICALL void           (* GL_APIENTRY glClearBufferfv) (GLenum buffer, GLint drawbuffer, const GLfloat* value);
+GL_APICALL void (*GL_APIENTRY glTransformFeedbackVaryings)(GLuint program, GLsizei count,
-GL_APICALL void           (* GL_APIENTRY glClearBufferfi) (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+                                                           GLchar const * const * varyings, GLenum bufferMode);
-GL_APICALL const GLubyte* (* GL_APIENTRY glGetStringi) (GLenum name, GLuint index);
+GL_APICALL void (*GL_APIENTRY glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize,
-GL_APICALL void           (* GL_APIENTRY glCopyBufferSubData) (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+                                                             GLsizei * length, GLsizei * size, GLenum * type,
-GL_APICALL void           (* GL_APIENTRY glGetUniformIndices) (GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices);
+                                                             GLchar * name);
-GL_APICALL void           (* GL_APIENTRY glGetActiveUniformsiv) (GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params);
+GL_APICALL void (*GL_APIENTRY glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride,
-GL_APICALL GLuint         (* GL_APIENTRY glGetUniformBlockIndex) (GLuint program, const GLchar* uniformBlockName);
+                                                      GLvoid const * pointer);
-GL_APICALL void           (* GL_APIENTRY glGetActiveUniformBlockiv) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
+GL_APICALL void (*GL_APIENTRY glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint * params);
-GL_APICALL void           (* GL_APIENTRY glGetActiveUniformBlockName) (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName);
+GL_APICALL void (*GL_APIENTRY glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint * params);
-GL_APICALL void           (* GL_APIENTRY glUniformBlockBinding) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+GL_APICALL void (*GL_APIENTRY glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
-GL_APICALL void           (* GL_APIENTRY glDrawArraysInstanced) (GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
+GL_APICALL void (*GL_APIENTRY glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-GL_APICALL void           (* GL_APIENTRY glDrawElementsInstanced) (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount);
+GL_APICALL void (*GL_APIENTRY glVertexAttribI4iv)(GLuint index, GLint const * v);
-GL_APICALL GLsync         (* GL_APIENTRY glFenceSync) (GLenum condition, GLbitfield flags);
+GL_APICALL void (*GL_APIENTRY glVertexAttribI4uiv)(GLuint index, GLuint const * v);
-GL_APICALL GLboolean      (* GL_APIENTRY glIsSync) (GLsync sync);
+GL_APICALL void (*GL_APIENTRY glGetUniformuiv)(GLuint program, GLint location, GLuint * params);
-GL_APICALL void           (* GL_APIENTRY glDeleteSync) (GLsync sync);
+GL_APICALL GLint (*GL_APIENTRY glGetFragDataLocation)(GLuint program, GLchar const * name);
-GL_APICALL GLenum         (* GL_APIENTRY glClientWaitSync) (GLsync sync, GLbitfield flags, GLuint64 timeout);
+GL_APICALL void (*GL_APIENTRY glUniform1ui)(GLint location, GLuint v0);
-GL_APICALL void           (* GL_APIENTRY glWaitSync) (GLsync sync, GLbitfield flags, GLuint64 timeout);
+GL_APICALL void (*GL_APIENTRY glUniform2ui)(GLint location, GLuint v0, GLuint v1);
-GL_APICALL void           (* GL_APIENTRY glGetInteger64v) (GLenum pname, GLint64* params);
+GL_APICALL void (*GL_APIENTRY glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
-GL_APICALL void           (* GL_APIENTRY glGetSynciv) (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values);
+GL_APICALL void (*GL_APIENTRY glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-GL_APICALL void           (* GL_APIENTRY glGetInteger64i_v) (GLenum target, GLuint index, GLint64* data);
+GL_APICALL void (*GL_APIENTRY glUniform1uiv)(GLint location, GLsizei count, GLuint const * value);
-GL_APICALL void           (* GL_APIENTRY glGetBufferParameteri64v) (GLenum target, GLenum pname, GLint64* params);
+GL_APICALL void (*GL_APIENTRY glUniform2uiv)(GLint location, GLsizei count, GLuint const * value);
-GL_APICALL void           (* GL_APIENTRY glGenSamplers) (GLsizei count, GLuint* samplers);
+GL_APICALL void (*GL_APIENTRY glUniform3uiv)(GLint location, GLsizei count, GLuint const * value);
-GL_APICALL void           (* GL_APIENTRY glDeleteSamplers) (GLsizei count, const GLuint* samplers);
+GL_APICALL void (*GL_APIENTRY glUniform4uiv)(GLint location, GLsizei count, GLuint const * value);
-GL_APICALL GLboolean      (* GL_APIENTRY glIsSampler) (GLuint sampler);
+GL_APICALL void (*GL_APIENTRY glClearBufferiv)(GLenum buffer, GLint drawbuffer, GLint const * value);
-GL_APICALL void           (* GL_APIENTRY glBindSampler) (GLuint unit, GLuint sampler);
+GL_APICALL void (*GL_APIENTRY glClearBufferuiv)(GLenum buffer, GLint drawbuffer, GLuint const * value);
-GL_APICALL void           (* GL_APIENTRY glSamplerParameteri) (GLuint sampler, GLenum pname, GLint param);
+GL_APICALL void (*GL_APIENTRY glClearBufferfv)(GLenum buffer, GLint drawbuffer, GLfloat const * value);
-GL_APICALL void           (* GL_APIENTRY glSamplerParameteriv) (GLuint sampler, GLenum pname, const GLint* param);
+GL_APICALL void (*GL_APIENTRY glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-GL_APICALL void           (* GL_APIENTRY glSamplerParameterf) (GLuint sampler, GLenum pname, GLfloat param);
+GL_APICALL const GLubyte * (*GL_APIENTRY glGetStringi)(GLenum name, GLuint index);
-GL_APICALL void           (* GL_APIENTRY glSamplerParameterfv) (GLuint sampler, GLenum pname, const GLfloat* param);
+GL_APICALL void (*GL_APIENTRY glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset,
-GL_APICALL void           (* GL_APIENTRY glGetSamplerParameteriv) (GLuint sampler, GLenum pname, GLint* params);
+                                                   GLintptr writeOffset, GLsizeiptr size);
-GL_APICALL void           (* GL_APIENTRY glGetSamplerParameterfv) (GLuint sampler, GLenum pname, GLfloat* params);
+GL_APICALL void (*GL_APIENTRY glGetUniformIndices)(GLuint program, GLsizei uniformCount,
-GL_APICALL void           (* GL_APIENTRY glVertexAttribDivisor) (GLuint index, GLuint divisor);
+                                                   GLchar const * const * uniformNames, GLuint * uniformIndices);
-GL_APICALL void           (* GL_APIENTRY glBindTransformFeedback) (GLenum target, GLuint id);
+GL_APICALL void (*GL_APIENTRY glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount,
-GL_APICALL void           (* GL_APIENTRY glDeleteTransformFeedbacks) (GLsizei n, const GLuint* ids);
+                                                     GLuint const * uniformIndices, GLenum pname, GLint * params);
-GL_APICALL void           (* GL_APIENTRY glGenTransformFeedbacks) (GLsizei n, GLuint* ids);
+GL_APICALL GLuint (*GL_APIENTRY glGetUniformBlockIndex)(GLuint program, GLchar const * uniformBlockName);
-GL_APICALL GLboolean      (* GL_APIENTRY glIsTransformFeedback) (GLuint id);
+GL_APICALL void (*GL_APIENTRY glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname,
-GL_APICALL void           (* GL_APIENTRY glPauseTransformFeedback) (void);
+                                                         GLint * params);
-GL_APICALL void           (* GL_APIENTRY glResumeTransformFeedback) (void);
+GL_APICALL void (*GL_APIENTRY glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize,
-GL_APICALL void           (* GL_APIENTRY glGetProgramBinary) (GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary);
+                                                           GLsizei * length, GLchar * uniformBlockName);
-GL_APICALL void           (* GL_APIENTRY glProgramBinary) (GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length);
+GL_APICALL void (*GL_APIENTRY glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex,
-GL_APICALL void           (* GL_APIENTRY glProgramParameteri) (GLuint program, GLenum pname, GLint value);
+                                                     GLuint uniformBlockBinding);
-GL_APICALL void           (* GL_APIENTRY glInvalidateFramebuffer) (GLenum target, GLsizei numAttachments, const GLenum* attachments);
+GL_APICALL void (*GL_APIENTRY glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount);
-GL_APICALL void           (* GL_APIENTRY glInvalidateSubFramebuffer) (GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height);
+GL_APICALL void (*GL_APIENTRY glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, GLvoid const * indices,
-GL_APICALL void           (* GL_APIENTRY glTexStorage2D) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+                                                       GLsizei instanceCount);
-GL_APICALL void           (* GL_APIENTRY glTexStorage3D) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+GL_APICALL GLsync (*GL_APIENTRY glFenceSync)(GLenum condition, GLbitfield flags);
-GL_APICALL void           (* GL_APIENTRY glGetInternalformativ) (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params);
+GL_APICALL GLboolean (*GL_APIENTRY glIsSync)(GLsync sync);
+GL_APICALL void (*GL_APIENTRY glDeleteSync)(GLsync sync);
+GL_APICALL GLenum (*GL_APIENTRY glClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+GL_APICALL void (*GL_APIENTRY glWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+GL_APICALL void (*GL_APIENTRY glGetInteger64v)(GLenum pname, GLint64 * params);
+GL_APICALL void (*GL_APIENTRY glGetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length,
+                                           GLint * values);
+GL_APICALL void (*GL_APIENTRY glGetInteger64i_v)(GLenum target, GLuint index, GLint64 * data);
+GL_APICALL void (*GL_APIENTRY glGetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 * params);
+GL_APICALL void (*GL_APIENTRY glGenSamplers)(GLsizei count, GLuint * samplers);
+GL_APICALL void (*GL_APIENTRY glDeleteSamplers)(GLsizei count, GLuint const * samplers);
+GL_APICALL GLboolean (*GL_APIENTRY glIsSampler)(GLuint sampler);
+GL_APICALL void (*GL_APIENTRY glBindSampler)(GLuint unit, GLuint sampler);
+GL_APICALL void (*GL_APIENTRY glSamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
+GL_APICALL void (*GL_APIENTRY glSamplerParameteriv)(GLuint sampler, GLenum pname, GLint const * param);
+GL_APICALL void (*GL_APIENTRY glSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param);
+GL_APICALL void (*GL_APIENTRY glSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat const * param);
+GL_APICALL void (*GL_APIENTRY glGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint * params);
+GL_APICALL void (*GL_APIENTRY glGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat * params);
+GL_APICALL void (*GL_APIENTRY glVertexAttribDivisor)(GLuint index, GLuint divisor);
+GL_APICALL void (*GL_APIENTRY glBindTransformFeedback)(GLenum target, GLuint id);
+GL_APICALL void (*GL_APIENTRY glDeleteTransformFeedbacks)(GLsizei n, GLuint const * ids);
+GL_APICALL void (*GL_APIENTRY glGenTransformFeedbacks)(GLsizei n, GLuint * ids);
+GL_APICALL GLboolean (*GL_APIENTRY glIsTransformFeedback)(GLuint id);
+GL_APICALL void (*GL_APIENTRY glPauseTransformFeedback)(void);
+GL_APICALL void (*GL_APIENTRY glResumeTransformFeedback)(void);
+GL_APICALL void (*GL_APIENTRY glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei * length,
+                                                  GLenum * binaryFormat, GLvoid * binary);
+GL_APICALL void (*GL_APIENTRY glProgramBinary)(GLuint program, GLenum binaryFormat, GLvoid const * binary,
+                                               GLsizei length);
+GL_APICALL void (*GL_APIENTRY glProgramParameteri)(GLuint program, GLenum pname, GLint value);
+GL_APICALL void (*GL_APIENTRY glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments,
+                                                       GLenum const * attachments);
+GL_APICALL void (*GL_APIENTRY glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments,
+                                                          GLenum const * attachments, GLint x, GLint y, GLsizei width,
+                                                          GLsizei height);
+GL_APICALL void (*GL_APIENTRY glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width,
+                                              GLsizei height);
+GL_APICALL void (*GL_APIENTRY glTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width,
+                                              GLsizei height, GLsizei depth);
+GL_APICALL void (*GL_APIENTRY glGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname,
+                                                     GLsizei bufSize, GLint * params);

android/sdk/src/main/cpp/app/organicmaps/sdk/platform/AndroidPlatform.cpp

@@ -22,17 +22,15 @@ std::string Platform::GetMemoryInfo() const
   if (env == nullptr)
     return std::string();
 
-  static std::shared_ptr<jobject> classLogsManager = jni::make_global_ref(env->FindClass("app/organicmaps/sdk/util/log/LogsManager"));
+  static std::shared_ptr<jobject> classLogsManager =
+      jni::make_global_ref(env->FindClass("app/organicmaps/sdk/util/log/LogsManager"));
   ASSERT(classLogsManager, ());
 
   jobject context = android::Platform::Instance().GetContext();
-  static jmethodID const getMemoryInfoId
+  static jmethodID const getMemoryInfoId = jni::GetStaticMethodID(
-    = jni::GetStaticMethodID(env,
+      env, static_cast<jclass>(*classLogsManager), "getMemoryInfo", "(Landroid/content/Context;)Ljava/lang/String;");
-                             static_cast<jclass>(*classLogsManager),
+  jstring const memInfoString = static_cast<jstring>(
-                             "getMemoryInfo",
+      env->CallStaticObjectMethod(static_cast<jclass>(*classLogsManager), getMemoryInfoId, context));
-                             "(Landroid/content/Context;)Ljava/lang/String;");
-  jstring const memInfoString = static_cast<jstring>(env->CallStaticObjectMethod(
-    static_cast<jclass>(*classLogsManager), getMemoryInfoId, context));
   ASSERT(memInfoString, ());
 
   return jni::ToNativeString(env, memInfoString);
@@ -41,20 +39,18 @@ std::string Platform::GetMemoryInfo() const
 std::string Platform::DeviceName() const
 {
   JNIEnv * env = jni::GetEnv();
-  static jmethodID const getDeviceNameId = jni::GetStaticMethodID(env, g_utilsClazz, "getDeviceName",
+  static jmethodID const getDeviceNameId =
-                                                                  "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getDeviceName", "()Ljava/lang/String;");
-  auto const deviceName = static_cast<jstring>(env->CallStaticObjectMethod(g_utilsClazz,
+  auto const deviceName = static_cast<jstring>(env->CallStaticObjectMethod(g_utilsClazz, getDeviceNameId));
-                                                                           getDeviceNameId));
   return jni::ToNativeString(env, deviceName);
 }
 
 std::string Platform::DeviceModel() const
 {
   JNIEnv * env = jni::GetEnv();
-  static jmethodID const getDeviceModelId = jni::GetStaticMethodID(env, g_utilsClazz, "getDeviceModel",
+  static jmethodID const getDeviceModelId =
-                                                                  "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getDeviceModel", "()Ljava/lang/String;");
-  auto const deviceModel = static_cast<jstring>(env->CallStaticObjectMethod(g_utilsClazz,
+  auto const deviceModel = static_cast<jstring>(env->CallStaticObjectMethod(g_utilsClazz, getDeviceModelId));
-                                                                            getDeviceModelId));
   return jni::ToNativeString(env, deviceModel);
 }
 
@@ -79,11 +75,14 @@ Platform::EConnectionType Platform::ConnectionStatus()
   if (env == nullptr)
     return EConnectionType::CONNECTION_NONE;
 
-  static std::shared_ptr<jobject> clazzConnectionState = jni::make_global_ref(env->FindClass("app/organicmaps/sdk/util/ConnectionState"));
+  static std::shared_ptr<jobject> clazzConnectionState =
+      jni::make_global_ref(env->FindClass("app/organicmaps/sdk/util/ConnectionState"));
   ASSERT(clazzConnectionState, ());
 
-  static jmethodID const getConnectionMethodId = jni::GetStaticMethodID(env, static_cast<jclass>(*clazzConnectionState), "getConnectionState", "()B");
+  static jmethodID const getConnectionMethodId =
-  return static_cast<Platform::EConnectionType>(env->CallStaticByteMethod(static_cast<jclass>(*clazzConnectionState), getConnectionMethodId));
+      jni::GetStaticMethodID(env, static_cast<jclass>(*clazzConnectionState), "getConnectionState", "()B");
+  return static_cast<Platform::EConnectionType>(
+      env->CallStaticByteMethod(static_cast<jclass>(*clazzConnectionState), getConnectionMethodId));
 }
 
 Platform::ChargingStatus Platform::GetChargingStatus()
@@ -92,8 +91,7 @@ Platform::ChargingStatus Platform::GetChargingStatus()
   if (env == nullptr)
     return Platform::ChargingStatus::Unknown;
 
-  static jclass const clazzBatteryState =
+  static jclass const clazzBatteryState = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/util/BatteryState");
-      jni::GetGlobalClassRef(env, "app/organicmaps/sdk/util/BatteryState");
   ASSERT(clazzBatteryState, ());
 
   static jmethodID const getChargingMethodId =
@@ -109,8 +107,7 @@ uint8_t Platform::GetBatteryLevel()
   if (env == nullptr)
     return 100;
 
-  static auto const clazzBatteryState =
+  static auto const clazzBatteryState = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/util/BatteryState");
-      jni::GetGlobalClassRef(env, "app/organicmaps/sdk/util/BatteryState");
   ASSERT(clazzBatteryState, ());
 
   static auto const getLevelMethodId =
@@ -123,22 +120,21 @@ namespace platform
 {
 platform::NetworkPolicy GetCurrentNetworkPolicy()
 {
-  JNIEnv *env = jni::GetEnv();
+  JNIEnv * env = jni::GetEnv();
   return platform::NetworkPolicy(network_policy::GetCurrentNetworkUsageStatus(env));
 }
-}
+}  // namespace platform
 
 namespace android
 {
 Platform::~Platform()
 {
-  JNIEnv *env = jni::GetEnv();
+  JNIEnv * env = jni::GetEnv();
   env->DeleteGlobalRef(m_context);
 }
 
-void Platform::Initialize(JNIEnv * env, jobject context, jstring apkPath,
+void Platform::Initialize(JNIEnv * env, jobject context, jstring apkPath, jstring writablePath, jstring privatePath,
-                          jstring writablePath, jstring privatePath, jstring tmpPath,
+                          jstring tmpPath, jstring flavorName, jstring buildType, bool isTablet)
-                          jstring flavorName, jstring buildType, bool isTablet)
 {
   m_context = env->NewGlobalRef(context);
   m_guiThread = std::make_unique<GuiThread>();
@@ -156,12 +152,10 @@ void Platform::Initialize(JNIEnv * env, jobject context, jstring apkPath,
   LOG(LINFO, ("Temporary path = ", m_tmpDir));
 
   // IMPORTANT: This method SHOULD be called from UI thread to cache static jni ID-s inside.
-  (void) ConnectionStatus();
+  (void)ConnectionStatus();
 }
 
-void Platform::OnExternalStorageStatusChanged(bool isAvailable)
+void Platform::OnExternalStorageStatusChanged(bool isAvailable) {}
-{
-}
 
 void Platform::SetWritableDir(std::string const & dir)
 {
@@ -173,7 +167,7 @@ void Platform::SetSettingsDir(std::string const & dir)
 {
   m_settingsDir = dir;
   // Logger is not fully initialized here.
-  //LOG(LINFO, ("Settings path = ", m_settingsDir));
+  // LOG(LINFO, ("Settings path = ", m_settingsDir));
 }
 
 bool Platform::HasAvailableSpaceForWriting(uint64_t size) const
@@ -209,13 +203,11 @@ void Platform::AndroidSecureStorage::Save(std::string const & key, std::string c
 
   Init(env);
 
-  static jmethodID const saveMethodId =
+  static jmethodID const saveMethodId = jni::GetStaticMethodID(env, m_secureStorageClass, "save",
-    jni::GetStaticMethodID(env, m_secureStorageClass, "save",
                                                                "(Landroid/content/Context;Ljava/lang/String;"
                                                                "Ljava/lang/String;)V");
   jobject context = android::Platform::Instance().GetContext();
-  env->CallStaticVoidMethod(m_secureStorageClass, saveMethodId,
+  env->CallStaticVoidMethod(m_secureStorageClass, saveMethodId, context,
-                            context,
                             jni::TScopedLocalRef(env, jni::ToJavaString(env, key)).get(),
                             jni::TScopedLocalRef(env, jni::ToJavaString(env, value)).get());
 }
@@ -228,14 +220,12 @@ bool Platform::AndroidSecureStorage::Load(std::string const & key, std::string &
 
   Init(env);
 
-  static jmethodID const loadMethodId =
+  static jmethodID const loadMethodId = jni::GetStaticMethodID(env, m_secureStorageClass, "load",
-    jni::GetStaticMethodID(env, m_secureStorageClass, "load",
                                                                "(Landroid/content/Context;Ljava/lang/String;)"
                                                                "Ljava/lang/String;");
   jobject context = android::Platform::Instance().GetContext();
-  auto const resultString = static_cast<jstring>(env->CallStaticObjectMethod(m_secureStorageClass,
+  auto const resultString = static_cast<jstring>(env->CallStaticObjectMethod(
-    loadMethodId, context,
+      m_secureStorageClass, loadMethodId, context, jni::TScopedLocalRef(env, jni::ToJavaString(env, key)).get()));
-    jni::TScopedLocalRef(env, jni::ToJavaString(env, key)).get()));
   if (resultString == nullptr)
     return false;
 
@@ -252,8 +242,7 @@ void Platform::AndroidSecureStorage::Remove(std::string const & key)
   Init(env);
 
   static jmethodID const removeMethodId =
-    jni::GetStaticMethodID(env, m_secureStorageClass, "remove",
+      jni::GetStaticMethodID(env, m_secureStorageClass, "remove", "(Landroid/content/Context;Ljava/lang/String;)V");
-                           "(Landroid/content/Context;Ljava/lang/String;)V");
   jobject context = android::Platform::Instance().GetContext();
   env->CallStaticVoidMethod(m_secureStorageClass, removeMethodId, context,
                             jni::TScopedLocalRef(env, jni::ToJavaString(env, key)).get());

android/sdk/src/main/cpp/app/organicmaps/sdk/platform/AndroidPlatform.hpp

@@ -20,8 +20,7 @@ public:
   ~Platform() override;
 
   void Initialize(JNIEnv * env, jobject functorProcessObject, jstring apkPath, jstring writablePath,
-                  jstring privatePath, jstring tmpPath, jstring flavorName,
+                  jstring privatePath, jstring tmpPath, jstring flavorName, jstring buildType, bool isTablet);
-                  jstring buildType, bool isTablet);
 
   void OnExternalStorageStatusChanged(bool isAvailable);
 

android/sdk/src/main/cpp/app/organicmaps/sdk/platform/HttpThread.cpp

@@ -11,12 +11,8 @@ private:
   jclass m_klass;
 
 public:
-  HttpThread(std::string const & url,
+  HttpThread(std::string const & url, downloader::IHttpThreadCallback & cb, int64_t beg, int64_t end,
-             downloader::IHttpThreadCallback & cb,
+             int64_t expectedFileSize, std::string const & pb)
-             int64_t beg,
-             int64_t end,
-             int64_t expectedFileSize,
-             std::string const & pb)
   {
     JNIEnv * env = jni::GetEnv();
     static jclass const klass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/downloader/ChunkTask");
@@ -35,14 +31,9 @@ public:
     }
 
     jni::TScopedLocalRef jUrl(env, jni::ToJavaString(env, url.c_str()));
-    jni::TScopedLocalRef localSelf(env, env->NewObject(klass,
+    jni::TScopedLocalRef localSelf(
-                                                       initMethodId,
+        env, env->NewObject(klass, initMethodId, reinterpret_cast<jlong>(&cb), jUrl.get(), static_cast<jlong>(beg),
-                                                       reinterpret_cast<jlong>(&cb),
+                            static_cast<jlong>(end), static_cast<jlong>(expectedFileSize), postBody.get()));
-                                                       jUrl.get(),
-                                                       static_cast<jlong>(beg),
-                                                       static_cast<jlong>(end),
-                                                       static_cast<jlong>(expectedFileSize),
-                                                       postBody.get()));
     m_self = env->NewGlobalRef(localSelf.get());
     ASSERT(m_self, ());
 
@@ -60,29 +51,26 @@ public:
 
 namespace downloader
 {
-  HttpThread * CreateNativeHttpThread(std::string const & url,
+HttpThread * CreateNativeHttpThread(std::string const & url, downloader::IHttpThreadCallback & cb, int64_t beg,
-                                      downloader::IHttpThreadCallback & cb,
+                                    int64_t end, int64_t size, std::string const & pb)
-                                      int64_t beg,
+{
-                                      int64_t end,
-                                      int64_t size,
-                                      std::string const & pb)
-  {
   return new HttpThread(url, cb, beg, end, size, pb);
-  }
+}
 
-  void DeleteNativeHttpThread(HttpThread * request)
+void DeleteNativeHttpThread(HttpThread * request)
-  {
+{
   delete request;
-  }
+}
 
 }  // namespace downloader
 
 extern "C"
 {
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_downloader_ChunkTask_nativeOnWrite(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_ChunkTask_nativeOnWrite(JNIEnv * env, jclass clazz, jlong httpCallbackID, jlong beg, jbyteArray data, jlong size)
+                                                                                       jlong httpCallbackID, jlong beg,
+                                                                                       jbyteArray data, jlong size)
 {
-  downloader::IHttpThreadCallback * cb = reinterpret_cast<downloader::IHttpThreadCallback*>(httpCallbackID);
+  downloader::IHttpThreadCallback * cb = reinterpret_cast<downloader::IHttpThreadCallback *>(httpCallbackID);
   jbyte * buf = env->GetByteArrayElements(data, 0);
   ASSERT(buf, ());
 
@@ -100,10 +88,12 @@ Java_app_organicmaps_sdk_downloader_ChunkTask_nativeOnWrite(JNIEnv * env, jclass
   return ret;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_downloader_ChunkTask_nativeOnFinish(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_downloader_ChunkTask_nativeOnFinish(JNIEnv * env, jclass clazz, jlong httpCallbackID, jlong httpCode, jlong beg, jlong end)
+                                                                                    jlong httpCallbackID,
+                                                                                    jlong httpCode, jlong beg,
+                                                                                    jlong end)
 {
-  downloader::IHttpThreadCallback * cb = reinterpret_cast<downloader::IHttpThreadCallback*>(httpCallbackID);
+  downloader::IHttpThreadCallback * cb = reinterpret_cast<downloader::IHttpThreadCallback *>(httpCallbackID);
   cb->OnFinish(static_cast<long>(httpCode), beg, end);
 }
 }  // extern "C"

android/sdk/src/main/cpp/app/organicmaps/sdk/platform/Language.cpp

@@ -1,5 +1,5 @@
-#include "android/sdk/src/main/cpp/app/organicmaps/sdk/core/jni_helper.hpp"
 #include "android/sdk/src/main/cpp/app/organicmaps/sdk/core/ScopedLocalRef.hpp"
+#include "android/sdk/src/main/cpp/app/organicmaps/sdk/core/jni_helper.hpp"
 
 #include "platform/locale.hpp"
 
@@ -22,11 +22,12 @@ std::string GetAndroidSystemLanguage()
   }
 
   static jclass const languageClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/util/Language");
-  static jmethodID const getDefaultLocaleId = jni::GetStaticMethodID(env, languageClass, "getDefaultLocale", "()Ljava/lang/String;");
+  static jmethodID const getDefaultLocaleId =
+      jni::GetStaticMethodID(env, languageClass, "getDefaultLocale", "()Ljava/lang/String;");
 
   jni::TScopedLocalRef localeRef(env, env->CallStaticObjectMethod(languageClass, getDefaultLocaleId));
 
-  std::string res = jni::ToNativeString(env, (jstring) localeRef.get());
+  std::string res = jni::ToNativeString(env, (jstring)localeRef.get());
   if (res.empty())
     res = DEFAULT_LANG;
 
@@ -38,24 +39,24 @@ namespace platform
 Locale GetCurrentLocale()
 {
   JNIEnv * env = jni::GetEnv();
-  static jmethodID const getLanguageCodeId = jni::GetStaticMethodID(env, g_utilsClazz, "getLanguageCode",
+  static jmethodID const getLanguageCodeId =
-                                                                    "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getLanguageCode", "()Ljava/lang/String;");
   jni::ScopedLocalRef languageCode(env, env->CallStaticObjectMethod(g_utilsClazz, getLanguageCodeId));
 
-  static jmethodID const getCountryCodeId = jni::GetStaticMethodID(env, g_utilsClazz, "getCountryCode",
+  static jmethodID const getCountryCodeId =
-                                                                   "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getCountryCode", "()Ljava/lang/String;");
   jni::ScopedLocalRef countryCode(env, env->CallStaticObjectMethod(g_utilsClazz, getCountryCodeId));
 
-  static jmethodID const getCurrencyCodeId = jni::GetStaticMethodID(env, g_utilsClazz, "getCurrencyCode",
+  static jmethodID const getCurrencyCodeId =
-                                                                    "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getCurrencyCode", "()Ljava/lang/String;");
   jni::ScopedLocalRef currencyCode(env, env->CallStaticObjectMethod(g_utilsClazz, getCurrencyCodeId));
 
-  static jmethodID const getDecimalSeparatorId = jni::GetStaticMethodID(env, g_utilsClazz, "getDecimalSeparator",
+  static jmethodID const getDecimalSeparatorId =
-                                                                        "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getDecimalSeparator", "()Ljava/lang/String;");
   jni::ScopedLocalRef decimalSeparatorChar(env, env->CallStaticObjectMethod(g_utilsClazz, getDecimalSeparatorId));
 
-  static jmethodID const getGroupingSeparatorId = jni::GetStaticMethodID(env, g_utilsClazz, "getGroupingSeparator",
+  static jmethodID const getGroupingSeparatorId =
-                                                                         "()Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getGroupingSeparator", "()Ljava/lang/String;");
   jni::ScopedLocalRef groupingSeparatorChar(env, env->CallStaticObjectMethod(g_utilsClazz, getGroupingSeparatorId));
 
   return {jni::ToNativeString(env, static_cast<jstring>(languageCode.get())),

android/sdk/src/main/cpp/app/organicmaps/sdk/platform/Localization.cpp

@@ -1,7 +1,7 @@
 #include <jni.h>
 
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/core/ScopedLocalRef.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/platform/AndroidPlatform.hpp"
 
 #include "platform/localization.hpp"
@@ -23,8 +23,7 @@ std::string GetLocalizedStringByUtil(jmethodID const & methodId, std::string con
 
   jni::TScopedLocalRef strRef(env, jni::ToJavaString(env, str));
   jobject context = android::Platform::Instance().GetContext();
-  jni::TScopedLocalRef localizedStrRef(env, env->CallStaticObjectMethod(g_utilsClazz, methodId,
+  jni::TScopedLocalRef localizedStrRef(env, env->CallStaticObjectMethod(g_utilsClazz, methodId, context, strRef.get()));
-                                                                        context, strRef.get()));
   return jni::ToNativeString(env, static_cast<jstring>(localizedStrRef.get()));
 }
 }  // namespace
@@ -52,12 +51,11 @@ std::string GetLocalizedString(std::string const & key)
 std::string GetCurrencySymbol(std::string const & currencyCode)
 {
   JNIEnv * env = jni::GetEnv();
-  static auto const methodId = jni::GetStaticMethodID(env, g_utilsClazz, "getCurrencySymbol",
+  static auto const methodId =
-                                                      "(Ljava/lang/String;)Ljava/lang/String;");
+      jni::GetStaticMethodID(env, g_utilsClazz, "getCurrencySymbol", "(Ljava/lang/String;)Ljava/lang/String;");
 
   jni::TScopedLocalRef currencyCodeRef(env, jni::ToJavaString(env, currencyCode));
-  jni::TScopedLocalRef localizedStrRef(
+  jni::TScopedLocalRef localizedStrRef(env, env->CallStaticObjectMethod(g_utilsClazz, methodId, currencyCodeRef.get()));
-      env, env->CallStaticObjectMethod(g_utilsClazz, methodId, currencyCodeRef.get()));
   return jni::ToNativeString(env, static_cast<jstring>(localizedStrRef.get()));
 }
 

android/sdk/src/main/cpp/app/organicmaps/sdk/platform/SocketImpl.cpp

@@ -30,8 +30,7 @@ public:
   bool Open(std::string const & host, uint16_t port)
   {
     JNIEnv * env = jni::GetEnv();
-    static jmethodID const openMethod =
+    static jmethodID const openMethod = jni::GetMethodID(env, m_self, "open", "(Ljava/lang/String;I)Z");
-        jni::GetMethodID(env, m_self, "open", "(Ljava/lang/String;I)Z");
     jni::TScopedLocalRef hostRef(env, jni::ToJavaString(env, host));
     jboolean result = env->CallBooleanMethod(m_self, openMethod, hostRef.get(), static_cast<jint>(port));
     if (jni::HandleJavaException(env))
@@ -55,7 +54,7 @@ public:
     jboolean result = env->CallBooleanMethod(m_self, readMethod, array, static_cast<jint>(count));
     if (jni::HandleJavaException(env))
       return false;
-    //this call copies java byte array to native buffer
+    // this call copies java byte array to native buffer
     env->GetByteArrayRegion(array, 0, count, reinterpret_cast<jbyte *>(data));
     if (jni::HandleJavaException(env))
       return false;
@@ -66,8 +65,8 @@ public:
   {
     JNIEnv * env = jni::GetEnv();
     jni::TScopedLocalByteArrayRef arrayRef(env, env->NewByteArray(count));
-    //this call copies native buffer to java byte array
+    // this call copies native buffer to java byte array
-    env->SetByteArrayRegion(arrayRef.get(), 0, count, reinterpret_cast<const jbyte *>(data));
+    env->SetByteArrayRegion(arrayRef.get(), 0, count, reinterpret_cast<jbyte const *>(data));
     static jmethodID const writeMethod = jni::GetMethodID(env, m_self, "write", "([BI)Z");
     jboolean result = env->CallBooleanMethod(m_self, writeMethod, arrayRef.get(), static_cast<jint>(count));
     if (jni::HandleJavaException(env))
@@ -81,11 +80,14 @@ public:
     static jmethodID const setTimeoutMethod = jni::GetMethodID(env, m_self, "setTimeout", "(I)V");
     env->CallVoidMethod(m_self, setTimeoutMethod, static_cast<jint>(milliseconds));
     jni::HandleJavaException(env);
-  };
+  }
 
 private:
   jobject m_self;
 };
 
-std::unique_ptr<Socket> CreateSocket() { return std::make_unique<SocketImpl>(); }
+std::unique_ptr<Socket> CreateSocket()
+{
+  return std::make_unique<SocketImpl>();
 }
+}  // namespace platform

android/sdk/src/main/cpp/app/organicmaps/sdk/routing/JunctionInfo.hpp

@@ -16,7 +16,6 @@ jobjectArray CreateJunctionInfoArray(JNIEnv * env, std::vector<geometry::PointWi
                           [](JNIEnv * env, geometry::PointWithAltitude const & pointWithAltitude)
   {
     auto & point = pointWithAltitude.GetPoint();
-                            return env->NewObject(junctionClazz, junctionConstructor, mercator::YToLat(point.y),
+    return env->NewObject(junctionClazz, junctionConstructor, mercator::YToLat(point.y), mercator::XToLon(point.x));
-                                                  mercator::XToLon(point.x));
   });
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/routing/RouteMarkData.hpp

@@ -14,13 +14,11 @@ jobjectArray CreateRouteMarkDataArray(JNIEnv * env, std::vector<RouteMarkData> c
   //                                boolean isPassed, double lat, double lon)
   static jmethodID const pointConstructor =
       jni::GetConstructorID(env, pointClazz, "(Ljava/lang/String;Ljava/lang/String;IIZZZDD)V");
-  return jni::ToJavaArray(env, pointClazz, points,
+  return jni::ToJavaArray(env, pointClazz, points, [&](JNIEnv * jEnv, RouteMarkData const & data)
-                          [&](JNIEnv * jEnv, RouteMarkData const & data)
   {
     jni::TScopedLocalRef const title(env, jni::ToJavaString(env, data.m_title));
     jni::TScopedLocalRef const subtitle(env, jni::ToJavaString(env, data.m_subTitle));
-                            return env->NewObject(
+    return env->NewObject(pointClazz, pointConstructor, title.get(), subtitle.get(),
-                              pointClazz, pointConstructor, title.get(), subtitle.get(),
                           static_cast<jint>(data.m_pointType), static_cast<jint>(data.m_intermediateIndex),
                           static_cast<jboolean>(data.m_isVisible), static_cast<jboolean>(data.m_isMyPosition),
                           static_cast<jboolean>(data.m_isPassed), mercator::YToLat(data.m_position.y),

android/sdk/src/main/cpp/app/organicmaps/sdk/routing/TransitStepInfo.hpp

@@ -14,15 +14,13 @@ jobjectArray CreateTransitStepInfoArray(JNIEnv * env, std::vector<TransitStepInf
   static jmethodID const transitStepConstructor =
       jni::GetConstructorID(env, transitStepClass, "(ILjava/lang/String;Ljava/lang/String;ILjava/lang/String;II)V");
 
-  return jni::ToJavaArray(
+  return jni::ToJavaArray(env, transitStepClass, steps, [&](JNIEnv * jEnv, TransitStepInfo const & stepInfo)
-    env, transitStepClass, steps,
-    [&](JNIEnv * jEnv, TransitStepInfo const & stepInfo)
   {
     jni::TScopedLocalRef const distance(env, jni::ToJavaString(env, stepInfo.m_distanceStr));
     jni::TScopedLocalRef const distanceUnits(env, jni::ToJavaString(env, stepInfo.m_distanceUnitsSuffix));
     jni::TScopedLocalRef const number(env, jni::ToJavaString(env, stepInfo.m_number));
-      return env->NewObject(transitStepClass, transitStepConstructor, static_cast<jint>(stepInfo.m_type),
+    return env->NewObject(transitStepClass, transitStepConstructor, static_cast<jint>(stepInfo.m_type), distance.get(),
-                            distance.get(), distanceUnits.get(), static_cast<jint>(stepInfo.m_timeInSec), number.get(),
+                          distanceUnits.get(), static_cast<jint>(stepInfo.m_timeInSec), number.get(),
                           static_cast<jint>(stepInfo.m_colorARGB), static_cast<jint>(stepInfo.m_intermediateIndex));
   });
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/search/DisplayedCategories.cpp

@@ -13,8 +13,9 @@ JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_search_DisplayedCategori
   return jni::ToJavaStringArray(env, categories.GetKeys());
 }
 
-JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_search_DisplayedCategories_nativeIsLangSupported(
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_search_DisplayedCategories_nativeIsLangSupported(JNIEnv * env,
-        JNIEnv * env, jclass, jstring langCode)
+                                                                                                     jclass,
+                                                                                                     jstring langCode)
 {
   return search::DisplayedCategories::IsLanguageSupported(jni::ToNativeString(env, langCode));
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/search/SearchEngine.cpp

@@ -65,13 +65,12 @@ bool PopularityHasHigherPriority(bool hasPosition, double distanceInMeters)
   return !hasPosition || distanceInMeters > search::Result::kPopularityHighPriorityMinDistance;
 }
 
-jobject ToJavaResult(Result const & result, search::ProductInfo const & productInfo,
+jobject ToJavaResult(Result const & result, search::ProductInfo const & productInfo, bool hasPosition, double lat,
-                     bool hasPosition, double lat, double lon)
+                     double lon)
 {
   JNIEnv * env = jni::GetEnv();
 
-  jni::TScopedLocalIntArrayRef ranges(
+  jni::TScopedLocalIntArrayRef ranges(env, env->NewIntArray(static_cast<jsize>(result.GetHighlightRangesCount() * 2)));
-      env, env->NewIntArray(static_cast<jsize>(result.GetHighlightRangesCount() * 2)));
   jint * rawArr = env->GetIntArrayElements(ranges, nullptr);
   for (size_t i = 0; i < result.GetHighlightRangesCount(); i++)
   {
@@ -81,8 +80,8 @@ jobject ToJavaResult(Result const & result, search::ProductInfo const & productI
   }
   env->ReleaseIntArrayElements(ranges.get(), rawArr, 0);
 
-  jni::TScopedLocalIntArrayRef descRanges(env, env->NewIntArray(
+  jni::TScopedLocalIntArrayRef descRanges(
-          static_cast<jsize>(result.GetDescHighlightRangesCount() * 2)));
+      env, env->NewIntArray(static_cast<jsize>(result.GetDescHighlightRangesCount() * 2)));
   jint * rawArr2 = env->GetIntArrayElements(descRanges, nullptr);
   for (size_t i = 0; i < result.GetDescHighlightRangesCount(); i++)
   {
@@ -100,7 +99,8 @@ jobject ToJavaResult(Result const & result, search::ProductInfo const & productI
   {
     jni::TScopedLocalRef name(env, jni::ToJavaString(env, result.GetString()));
     jni::TScopedLocalRef suggest(env, jni::ToJavaString(env, result.GetSuggestionString()));
-    return env->NewObject(g_resultClass, g_suggestConstructor, name.get(), suggest.get(), ll.m_lat, ll.m_lon, ranges.get(),descRanges.get());
+    return env->NewObject(g_resultClass, g_suggestConstructor, name.get(), suggest.get(), ll.m_lat, ll.m_lon,
+                          ranges.get(), descRanges.get());
   }
 
   platform::Distance distance;
@@ -113,34 +113,31 @@ jobject ToJavaResult(Result const & result, search::ProductInfo const & productI
 
   bool const popularityHasHigherPriority = PopularityHasHigherPriority(hasPosition, distanceInMeters);
   bool const isFeature = result.GetResultType() == Result::Type::Feature;
-  jni::TScopedLocalRef featureId(env, usermark_helper::CreateFeatureId(env, isFeature ?
+  jni::TScopedLocalRef featureId(
-                                                                            result.GetFeatureID() :
+      env, usermark_helper::CreateFeatureId(env, isFeature ? result.GetFeatureID() : kEmptyFeatureId));
-                                                                            kEmptyFeatureId));
 
   jni::TScopedLocalRef featureType(env, jni::ToJavaString(env, result.GetLocalizedFeatureType()));
   jni::TScopedLocalRef address(env, jni::ToJavaString(env, result.GetAddress()));
   jni::TScopedLocalRef dist(env, ToJavaDistance(env, distance));
   jni::TScopedLocalRef description(env, jni::ToJavaString(env, result.GetFeatureDescription()));
 
-  jni::TScopedLocalRef desc(env, env->NewObject(g_descriptionClass, g_descriptionConstructor,
+  jni::TScopedLocalRef desc(
-                                                featureId.get(), featureType.get(), address.get(),
+      env,
-                                                dist.get(), description.get(),
+      env->NewObject(g_descriptionClass, g_descriptionConstructor, featureId.get(), featureType.get(), address.get(),
-                                                static_cast<jint>(result.IsOpenNow()),
+                     dist.get(), description.get(), static_cast<jint>(result.IsOpenNow()), result.GetMinutesUntilOpen(),
-                                                result.GetMinutesUntilOpen(),result.GetMinutesUntilClosed(),
+                     result.GetMinutesUntilClosed(), static_cast<jboolean>(popularityHasHigherPriority)));
-                                                static_cast<jboolean>(popularityHasHigherPriority)));
 
   jni::TScopedLocalRef name(env, jni::ToJavaString(env, result.GetString()));
-  jni::TScopedLocalRef popularity(env, env->NewObject(g_popularityClass,
+  jni::TScopedLocalRef popularity(env, env->NewObject(g_popularityClass, g_popularityConstructor,
-                                                      g_popularityConstructor,
                                                       /// @todo Restore when popularity will be available
-                                                      0/*static_cast<jint>(result.GetRankingInfo().m_popularity)*/));
+                                                      0 /*static_cast<jint>(result.GetRankingInfo().m_popularity)*/));
 
-  return env->NewObject(g_resultClass, g_resultConstructor, name.get(), desc.get(), ll.m_lat, ll.m_lon,
+  return env->NewObject(g_resultClass, g_resultConstructor, name.get(), desc.get(), ll.m_lat, ll.m_lon, ranges.get(),
-                        ranges.get(), descRanges.get(), popularity.get());
+                        descRanges.get(), popularity.get());
 }
 
-jobjectArray BuildSearchResults(vector<search::ProductInfo> const & productInfo,
+jobjectArray BuildSearchResults(vector<search::ProductInfo> const & productInfo, bool hasPosition, double lat,
-                                bool hasPosition, double lat, double lon)
+                                double lon)
 {
   JNIEnv * env = jni::GetEnv();
 
@@ -154,8 +151,8 @@ jobjectArray BuildSearchResults(vector<search::ProductInfo> const & productInfo,
   return jResults;
 }
 
-void OnResults(Results results, vector<search::ProductInfo> const & productInfo,
+void OnResults(Results results, vector<search::ProductInfo> const & productInfo, jlong timestamp, bool isMapAndTable,
-               jlong timestamp, bool isMapAndTable, bool hasPosition, double lat, double lon)
+               bool hasPosition, double lat, double lon)
 {
   // Ignore results from obsolete searches.
   if (g_queryTimestamp > timestamp)
@@ -203,8 +200,8 @@ void OnMapSearchResults(storage::DownloaderSearchResults const & results, long l
 
   JNIEnv * env = jni::GetEnv();
   jni::TScopedLocalObjectArrayRef jResults(env, BuildJavaMapResults(results.m_results));
-  env->CallVoidMethod(g_javaListener, g_mapResultsMethod, jResults.get(),
+  env->CallVoidMethod(g_javaListener, g_mapResultsMethod, jResults.get(), static_cast<jlong>(timestamp),
-                      static_cast<jlong>(timestamp), results.m_endMarker);
+                      results.m_endMarker);
 }
 
 void OnBookmarksSearchResults(search::BookmarksSearchParams::Results results,
@@ -221,8 +218,8 @@ void OnBookmarksSearchResults(search::BookmarksSearchParams::Results results,
   vector<jlong> const tmp(results.cbegin(), results.cend());
   env->SetLongArrayRegion(jResults.get(), 0, static_cast<jsize>(tmp.size()), tmp.data());
 
-  auto const method = (status == search::BookmarksSearchParams::Status::InProgress) ?
+  auto const method = (status == search::BookmarksSearchParams::Status::InProgress) ? g_updateBookmarksResultsId
-                      g_updateBookmarksResultsId : g_endBookmarksResultsId;
+                                                                                    : g_endBookmarksResultsId;
 
   env->CallVoidMethod(g_javaListener, method, jResults.get(), static_cast<jlong>(timestamp));
 }
@@ -231,18 +228,17 @@ void OnBookmarksSearchResults(search::BookmarksSearchParams::Results results,
 
 extern "C"
 {
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeInit(JNIEnv * env, jobject thiz)
-  Java_app_organicmaps_sdk_search_SearchEngine_nativeInit(JNIEnv * env, jobject thiz)
+{
-  {
   g_javaListener = env->NewGlobalRef(thiz);
   // public void onResultsUpdate(@NonNull SearchResult[] results, long timestamp)
-    g_updateResultsId = jni::GetMethodID(env, g_javaListener, "onResultsUpdate",
+  g_updateResultsId =
-                                         "([Lapp/organicmaps/sdk/search/SearchResult;J)V");
+      jni::GetMethodID(env, g_javaListener, "onResultsUpdate", "([Lapp/organicmaps/sdk/search/SearchResult;J)V");
   // public void onResultsEnd(long timestamp)
   g_endResultsId = jni::GetMethodID(env, g_javaListener, "onResultsEnd", "(J)V");
   g_resultClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/search/SearchResult");
-    g_resultConstructor = jni::GetConstructorID(
+  g_resultConstructor =
-        env, g_resultClass,
+      jni::GetConstructorID(env, g_resultClass,
                             "(Ljava/lang/String;Lapp/organicmaps/sdk/search/SearchResult$Description;DD[I[I"
                             "Lapp/organicmaps/sdk/search/Popularity;)V");
   g_suggestConstructor = jni::GetConstructorID(env, g_resultClass, "(Ljava/lang/String;Ljava/lang/String;DD[I[I)V");
@@ -252,7 +248,8 @@ extern "C"
                   String description, int openNow, int minutesUntilOpen, int minutesUntilClosed,
                   boolean hasPopularityHigherPriority)
   */
-    g_descriptionConstructor = jni::GetConstructorID(env, g_descriptionClass,
+  g_descriptionConstructor =
+      jni::GetConstructorID(env, g_descriptionClass,
                             "(Lapp/organicmaps/sdk/bookmarks/data/FeatureId;"
                             "Ljava/lang/String;Ljava/lang/String;Lapp/organicmaps/sdk/util/Distance;"
                             "Ljava/lang/String;IIIZ)V");
@@ -265,33 +262,29 @@ extern "C"
   g_mapResultClass = jni::GetGlobalClassRef(env, "app/organicmaps/sdk/search/MapSearchListener$Result");
   g_mapResultCtor = jni::GetConstructorID(env, g_mapResultClass, "(Ljava/lang/String;Ljava/lang/String;)V");
 
-    g_updateBookmarksResultsId =
+  g_updateBookmarksResultsId = jni::GetMethodID(env, g_javaListener, "onBookmarkSearchResultsUpdate", "([JJ)V");
-      jni::GetMethodID(env, g_javaListener, "onBookmarkSearchResultsUpdate", "([JJ)V");
+  g_endBookmarksResultsId = jni::GetMethodID(env, g_javaListener, "onBookmarkSearchResultsEnd", "([JJ)V");
-    g_endBookmarksResultsId =
+}
-      jni::GetMethodID(env, g_javaListener, "onBookmarkSearchResultsEnd", "([JJ)V");
-  }
 
-  JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunSearch(
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunSearch(
-      JNIEnv * env, jclass clazz, jbyteArray bytes, jboolean isCategory,
+    JNIEnv * env, jclass clazz, jbyteArray bytes, jboolean isCategory, jstring lang, jlong timestamp,
-      jstring lang, jlong timestamp, jboolean hasPosition, jdouble lat, jdouble lon)
+    jboolean hasPosition, jdouble lat, jdouble lon)
-  {
+{
-    search::EverywhereSearchParams params{
+  search::EverywhereSearchParams params{jni::ToNativeString(env, bytes),
-        jni::ToNativeString(env, bytes),
                                         jni::ToNativeString(env, lang),
                                         {},  // default timeout
                                         static_cast<bool>(isCategory),
-        bind(&OnResults, _1, _2, timestamp, false, hasPosition, lat, lon)
+                                        bind(&OnResults, _1, _2, timestamp, false, hasPosition, lat, lon)};
-    };
   bool const searchStarted = g_framework->NativeFramework()->GetSearchAPI().SearchEverywhere(std::move(params));
   if (searchStarted)
     g_queryTimestamp = timestamp;
   return searchStarted;
-  }
+}
 
-  JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunInteractiveSearch(
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunInteractiveSearch(
-      JNIEnv * env, jclass clazz, jbyteArray bytes, jboolean isCategory,
+    JNIEnv * env, jclass clazz, jbyteArray bytes, jboolean isCategory, jstring lang, jlong timestamp,
-      jstring lang, jlong timestamp, jboolean isMapAndTable, jboolean hasPosition, jdouble lat, jdouble lon)
+    jboolean isMapAndTable, jboolean hasPosition, jdouble lat, jdouble lon)
-  {
+{
   search::ViewportSearchParams vparams{
       jni::ToNativeString(env, bytes),
       jni::ToNativeString(env, lang),
@@ -308,74 +301,66 @@ extern "C"
 
   if (isMapAndTable)
   {
-      search::EverywhereSearchParams eparams{
+    search::EverywhereSearchParams eparams{std::move(vparams.m_query),
-          std::move(vparams.m_query),
                                            std::move(vparams.m_inputLocale),
                                            {},  // default timeout
                                            static_cast<bool>(isCategory),
-          bind(&OnResults, _1, _2, timestamp, isMapAndTable, hasPosition, lat, lon)
+                                           bind(&OnResults, _1, _2, timestamp, isMapAndTable, hasPosition, lat, lon)};
-      };
 
     if (g_framework->NativeFramework()->GetSearchAPI().SearchEverywhere(std::move(eparams)))
       g_queryTimestamp = timestamp;
   }
-  }
+}
 
-  JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunSearchMaps(
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunSearchMaps(JNIEnv * env, jclass clazz,
-      JNIEnv * env, jclass clazz, jbyteArray bytes, jstring lang, jlong timestamp)
+                                                                                        jbyteArray bytes, jstring lang,
-  {
+                                                                                        jlong timestamp)
-    storage::DownloaderSearchParams params{
+{
-        jni::ToNativeString(env, bytes),
+  storage::DownloaderSearchParams params{jni::ToNativeString(env, bytes), jni::ToNativeString(env, lang),
-        jni::ToNativeString(env, lang),
+                                         bind(&OnMapSearchResults, _1, timestamp)};
-        bind(&OnMapSearchResults, _1, timestamp)
-    };
 
   if (g_framework->NativeFramework()->GetSearchAPI().SearchInDownloader(std::move(params)))
     g_queryTimestamp = timestamp;
-  }
+}
 
-  JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunSearchInBookmarks(
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeRunSearchInBookmarks(
     JNIEnv * env, jclass clazz, jbyteArray query, jlong catId, jlong timestamp)
-  {
+{
-    search::BookmarksSearchParams params{
+  search::BookmarksSearchParams params{jni::ToNativeString(env, query), static_cast<kml::MarkGroupId>(catId),
-        jni::ToNativeString(env, query),
+                                       bind(&OnBookmarksSearchResults, _1, _2, timestamp)};
-        static_cast<kml::MarkGroupId>(catId),
-        bind(&OnBookmarksSearchResults, _1, _2, timestamp)
-    };
 
   bool const searchStarted = g_framework->NativeFramework()->GetSearchAPI().SearchInBookmarks(std::move(params));
   if (searchStarted)
     g_queryTimestamp = timestamp;
   return searchStarted;
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeShowResult(JNIEnv * env, jclass clazz,
-  Java_app_organicmaps_sdk_search_SearchEngine_nativeShowResult(JNIEnv * env, jclass clazz, jint index)
+                                                                                     jint index)
-  {
+{
   g_framework->NativeFramework()->ShowSearchResult(g_results[index]);
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeCancelInteractiveSearch(JNIEnv * env,
-  Java_app_organicmaps_sdk_search_SearchEngine_nativeCancelInteractiveSearch(JNIEnv * env, jclass clazz)
+                                                                                                  jclass clazz)
-  {
+{
   g_framework->NativeFramework()->GetSearchAPI().CancelSearch(search::Mode::Viewport);
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeCancelEverywhereSearch(JNIEnv * env,
-  Java_app_organicmaps_sdk_search_SearchEngine_nativeCancelEverywhereSearch(JNIEnv * env, jclass clazz)
+                                                                                                 jclass clazz)
-  {
+{
   g_framework->NativeFramework()->GetSearchAPI().CancelSearch(search::Mode::Everywhere);
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeCancelAllSearches(JNIEnv * env, jclass clazz)
-  Java_app_organicmaps_sdk_search_SearchEngine_nativeCancelAllSearches(JNIEnv * env, jclass clazz)
+{
-  {
   g_framework->NativeFramework()->GetSearchAPI().CancelAllSearches();
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_search_SearchEngine_nativeUpdateViewportWithLastResults(JNIEnv * env,
-  Java_app_organicmaps_sdk_search_SearchEngine_nativeUpdateViewportWithLastResults(JNIEnv * env, jclass clazz)
+                                                                                                        jclass clazz)
-  {
+{
   g_framework->NativeFramework()->UpdateViewport(g_results);
-  }
+}
 }  // extern "C"

android/sdk/src/main/cpp/app/organicmaps/sdk/settings/MapLanguageCode.cpp

@@ -6,14 +6,13 @@
 
 extern "C"
 {
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_settings_MapLanguageCode_setMapLanguageCode(JNIEnv * env, jobject,
-Java_app_organicmaps_sdk_settings_MapLanguageCode_setMapLanguageCode(JNIEnv * env, jobject, jstring languageCode)
+                                                                                            jstring languageCode)
 {
   g_framework->SetMapLanguageCode(jni::ToNativeString(env, languageCode));
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_settings_MapLanguageCode_getMapLanguageCode(JNIEnv * env, jobject)
-Java_app_organicmaps_sdk_settings_MapLanguageCode_getMapLanguageCode(JNIEnv * env, jobject)
 {
   return jni::ToJavaString(env, g_framework->GetMapLanguageCode());
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/settings/UnitLocale.cpp

@@ -5,19 +5,17 @@
 
 extern "C"
 {
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_settings_UnitLocale_setCurrentUnits(JNIEnv * env, jobject thiz,
-  Java_app_organicmaps_sdk_settings_UnitLocale_setCurrentUnits(JNIEnv * env, jobject thiz, jint units)
+                                                                                    jint units)
-  {
+{
   measurement_utils::Units const u = static_cast<measurement_utils::Units>(units);
   settings::Set(settings::kMeasurementUnits, u);
   g_framework->SetupMeasurementSystem();
-  }
+}
-
+
-  JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_settings_UnitLocale_getCurrentUnits(JNIEnv * env, jobject thiz)
-  Java_app_organicmaps_sdk_settings_UnitLocale_getCurrentUnits(JNIEnv * env, jobject thiz)
+{
-  {
+  measurement_utils::Units u;
-    measurement_utils::Units u;
+  return static_cast<jint>(settings::Get(settings::kMeasurementUnits, u) ? u : measurement_utils::Units::Metric);
-    return static_cast<jint>(
+}
-        settings::Get(settings::kMeasurementUnits, u) ? u : measurement_utils::Units::Metric);
-  }
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/sound/tts.cpp

@@ -7,32 +7,30 @@
 
 extern "C"
 {
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_sound_TtsPlayer_nativeEnableTurnNotifications(JNIEnv *, jclass,
-Java_app_organicmaps_sdk_sound_TtsPlayer_nativeEnableTurnNotifications(JNIEnv *, jclass, jboolean enable)
+                                                                                              jboolean enable)
 {
   return frm()->GetRoutingManager().EnableTurnNotifications(static_cast<bool>(enable));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_sound_TtsPlayer_nativeAreTurnNotificationsEnabled(JNIEnv *, jclass)
-Java_app_organicmaps_sdk_sound_TtsPlayer_nativeAreTurnNotificationsEnabled(JNIEnv *, jclass)
 {
   return static_cast<jboolean>(frm()->GetRoutingManager().AreTurnNotificationsEnabled());
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_sound_TtsPlayer_nativeSetTurnNotificationsLocale(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_sound_TtsPlayer_nativeSetTurnNotificationsLocale(JNIEnv * env, jclass, jstring jLocale)
+                                                                                                 jstring jLocale)
 {
   frm()->GetRoutingManager().SetTurnNotificationsLocale(jni::ToNativeString(env, jLocale));
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_sound_TtsPlayer_nativeGetTurnNotificationsLocale(JNIEnv * env,
-Java_app_organicmaps_sdk_sound_TtsPlayer_nativeGetTurnNotificationsLocale(JNIEnv * env, jclass)
+                                                                                                    jclass)
 {
   return jni::ToJavaString(env, frm()->GetRoutingManager().GetTurnNotificationsLocale());
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_sound_TtsPlayer_nativeGetSupportedLanguages(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_sound_TtsPlayer_nativeGetSupportedLanguages(JNIEnv * env, jclass)
 {
   auto const & supportedLanguages = routing::turns::sound::kLanguageList;
 

android/sdk/src/main/cpp/app/organicmaps/sdk/subway/SubwayManager.cpp

@@ -9,22 +9,21 @@ static void TransitSchemeStateChanged(TransitReadManager::TransitSchemeState sta
                                       std::shared_ptr<jobject> const & listener)
 {
   JNIEnv * env = jni::GetEnv();
-  env->CallVoidMethod(*listener,
+  env->CallVoidMethod(*listener, jni::GetMethodID(env, *listener, "onTransitStateChanged", "(I)V"),
-                      jni::GetMethodID(env, *listener, "onTransitStateChanged", "(I)V"),
                       static_cast<jint>(state));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_subway_SubwayManager_nativeAddListener(JNIEnv * env,
-Java_app_organicmaps_sdk_maplayer_subway_SubwayManager_nativeAddListener(JNIEnv *env, jclass clazz, jobject listener)
+                                                                                                jclass clazz,
+                                                                                                jobject listener)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
-  g_framework->SetTransitSchemeListener(std::bind(&TransitSchemeStateChanged,
+  g_framework->SetTransitSchemeListener(
-                                                  std::placeholders::_1,
+      std::bind(&TransitSchemeStateChanged, std::placeholders::_1, jni::make_global_ref(listener)));
-                                                  jni::make_global_ref(listener)));
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_maplayer_subway_SubwayManager_nativeRemoveListener(JNIEnv * env,
-Java_app_organicmaps_sdk_maplayer_subway_SubwayManager_nativeRemoveListener(JNIEnv * env, jclass clazz)
+                                                                                                   jclass clazz)
 {
   CHECK(g_framework, ("Framework isn't created yet!"));
   g_framework->SetTransitSchemeListener(TransitReadManager::TransitStateChangedFn());

android/sdk/src/main/cpp/app/organicmaps/sdk/util/Config.cpp

@@ -1,126 +1,122 @@
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/Framework.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "platform/settings.hpp"
 
 extern "C"
 {
-  JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_util_Config_nativeHasConfigValue(JNIEnv * env, jclass thiz,
-  Java_app_organicmaps_sdk_util_Config_nativeHasConfigValue(JNIEnv * env, jclass thiz, jstring name)
+                                                                                     jstring name)
-  {
+{
   std::string value;
   return settings::Get(jni::ToNativeString(env, name), value);
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeDeleteConfigValue(JNIEnv * env, jclass thiz,
-  Java_app_organicmaps_sdk_util_Config_nativeDeleteConfigValue(JNIEnv * env, jclass thiz, jstring name)
+                                                                                    jstring name)
-  {
+{
   settings::Delete(jni::ToNativeString(env, name));
-  }
+}
 
-  JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetBoolean(JNIEnv * env, jclass thiz,
-  Java_app_organicmaps_sdk_util_Config_nativeGetBoolean(JNIEnv * env, jclass thiz, jstring name, jboolean defaultVal)
+                                                                                 jstring name, jboolean defaultVal)
-  {
+{
   bool val;
   if (settings::Get(jni::ToNativeString(env, name), val))
     return static_cast<jboolean>(val);
 
   return defaultVal;
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetBoolean(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeSetBoolean(JNIEnv * env, jclass thiz, jstring name, jboolean val)
+                                                                             jboolean val)
-  {
+{
   (void)settings::Set(jni::ToNativeString(env, name), static_cast<bool>(val));
-  }
+}
 
-  JNIEXPORT jint JNICALL
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetInt(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeGetInt(JNIEnv * env, jclass thiz, jstring name, jint defaultValue)
+                                                                         jint defaultValue)
-  {
+{
   int32_t value;
   if (settings::Get(jni::ToNativeString(env, name), value))
     return static_cast<jint>(value);
 
   return defaultValue;
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetInt(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeSetInt(JNIEnv * env, jclass thiz, jstring name, jint value)
+                                                                         jint value)
-  {
+{
   (void)settings::Set(jni::ToNativeString(env, name), static_cast<int32_t>(value));
-  }
+}
 
-  JNIEXPORT jlong JNICALL
+JNIEXPORT jlong JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetLong(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeGetLong(JNIEnv * env, jclass thiz, jstring name, jlong defaultValue)
+                                                                           jlong defaultValue)
-  {
+{
   int64_t value;
   if (settings::Get(jni::ToNativeString(env, name), value))
     return static_cast<jlong>(value);
 
   return defaultValue;
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetLong(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeSetLong(JNIEnv * env, jclass thiz, jstring name, jlong value)
+                                                                          jlong value)
-  {
+{
   (void)settings::Set(jni::ToNativeString(env, name), static_cast<int64_t>(value));
-  }
+}
 
-  JNIEXPORT jdouble JNICALL
+JNIEXPORT jdouble JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetDouble(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeGetDouble(JNIEnv * env, jclass thiz, jstring name, jdouble defaultValue)
+                                                                               jdouble defaultValue)
-  {
+{
   double value;
   if (settings::Get(jni::ToNativeString(env, name), value))
     return static_cast<jdouble>(value);
 
   return defaultValue;
-  }
+}
 
-  JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetDouble(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeSetDouble(JNIEnv * env, jclass thiz, jstring name, jdouble value)
+                                                                            jdouble value)
-  {
+{
   (void)settings::Set(jni::ToNativeString(env, name), static_cast<double>(value));
-  }
+}
 
-  JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetString(JNIEnv * env, jclass thiz, jstring name,
-  Java_app_organicmaps_sdk_util_Config_nativeGetString(JNIEnv * env, jclass thiz, jstring name, jstring defaultValue)
+                                                                               jstring defaultValue)
-  {
+{
   std::string value;
   if (settings::Get(jni::ToNativeString(env, name), value))
     return jni::ToJavaString(env, value);
 
   return defaultValue;
-  }
+}
 
-    JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetString(JNIEnv * env, jclass thiz, jstring name,
-    Java_app_organicmaps_sdk_util_Config_nativeSetString(JNIEnv * env, jclass thiz, jstring name, jstring value)
+                                                                            jstring value)
-    {
+{
   (void)settings::Set(jni::ToNativeString(env, name), jni::ToNativeString(env, value));
-    }
+}
 
-    JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetLargeFontsSize(JNIEnv * env, jclass thiz)
-    Java_app_organicmaps_sdk_util_Config_nativeGetLargeFontsSize(JNIEnv * env, jclass thiz)
+{
-    {
   return frm()->LoadLargeFontsSize();
-    }
+}
 
-    JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetLargeFontsSize(JNIEnv * env, jclass thiz,
-    Java_app_organicmaps_sdk_util_Config_nativeSetLargeFontsSize(JNIEnv * env, jclass thiz,
                                                                                     jboolean value)
-    {
+{
   frm()->SetLargeFontsSize(value);
-    }
+}
 
-    JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_util_Config_nativeGetTransliteration(JNIEnv * env, jclass thiz)
-    Java_app_organicmaps_sdk_util_Config_nativeGetTransliteration(JNIEnv * env, jclass thiz)
+{
-    {
   return frm()->LoadTransliteration();
-    }
+}
 
-    JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_Config_nativeSetTransliteration(JNIEnv * env, jclass thiz,
-    Java_app_organicmaps_sdk_util_Config_nativeSetTransliteration(JNIEnv * env, jclass thiz,
                                                                                      jboolean value)
-    {
+{
   frm()->SaveTransliteration(value);
   frm()->AllowTransliteration(value);
-    }
+}
 }  // extern "C"

android/sdk/src/main/cpp/app/organicmaps/sdk/util/Distance.hpp

@@ -10,9 +10,9 @@ inline jobject ToJavaDistance(JNIEnv * env, platform::Distance const & distance)
 
   static jmethodID const distanceConstructor = jni::GetConstructorID(env, distanceClass, "(DLjava/lang/String;B)V");
 
-  jobject distanceObject = env->NewObject(
+  jobject distanceObject =
-      distanceClass, distanceConstructor,
+      env->NewObject(distanceClass, distanceConstructor, distance.GetDistance(),
-      distance.GetDistance(), jni::ToJavaString(env, distance.GetDistanceString()), static_cast<uint8_t>(distance.GetUnits()));
+                     jni::ToJavaString(env, distance.GetDistanceString()), static_cast<uint8_t>(distance.GetUnits()));
 
   return distanceObject;
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/util/GeoUtils.cpp

@@ -4,9 +4,8 @@
 
 extern "C"
 {
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_util_GeoUtils_nativeToLatLon(JNIEnv * env, jobject thiz,
-  Java_app_organicmaps_sdk_util_GeoUtils_nativeToLatLon(
+                                                                                jdouble mercX, jdouble mercY)
-  JNIEnv * env, jobject thiz, jdouble mercX, jdouble mercY)
 {
   auto const mercPoint = m2::PointD(static_cast<double>(mercX), static_cast<double>(mercY));
   auto const latLon = mercator::ToLatLon(mercPoint);

android/sdk/src/main/cpp/app/organicmaps/sdk/util/HttpClient.cpp

@@ -23,9 +23,9 @@ SOFTWARE.
 *******************************************************************************/
 #include <jni.h>
 
-#include "app/organicmaps/sdk/core/jni_helper.hpp"
 #include "app/organicmaps/sdk/core/ScopedEnv.hpp"
 #include "app/organicmaps/sdk/core/ScopedLocalRef.hpp"
+#include "app/organicmaps/sdk/core/jni_helper.hpp"
 
 #include "platform/http_client.hpp"
 
@@ -33,8 +33,8 @@ SOFTWARE.
 #include "base/exception.hpp"
 #include "base/logging.hpp"
 
-#include <string>
 #include <iterator>
+#include <string>
 #include <unordered_map>
 
 DECLARE_EXCEPTION(JniException, RootException);
@@ -51,8 +51,7 @@ void RethrowOnJniException(ScopedEnv & env)
   MYTHROW(JniException, ());
 }
 
-jfieldID GetHttpParamsFieldId(ScopedEnv & env, const char * name,
+jfieldID GetHttpParamsFieldId(ScopedEnv & env, char const * name, char const * signature = "Ljava/lang/String;")
-                              const char * signature = "Ljava/lang/String;")
 {
   return env->GetFieldID(g_httpParamsClazz, name, signature);
 }
@@ -85,8 +84,8 @@ void SetInt(ScopedEnv & env, jobject params, jfieldID const fieldId, int const v
 // Get string value from HttpClient.Params object, throws JniException.
 void GetString(ScopedEnv & env, jobject const params, jfieldID const fieldId, std::string & result)
 {
-  jni::ScopedLocalRef<jstring> const wrappedValue(
+  jni::ScopedLocalRef<jstring> const wrappedValue(env.get(),
-      env.get(), static_cast<jstring>(env->GetObjectField(params, fieldId)));
+                                                  static_cast<jstring>(env->GetObjectField(params, fieldId)));
   RethrowOnJniException(env);
   if (wrappedValue)
     result = jni::ToNativeString(env.get(), wrappedValue.get());
@@ -103,8 +102,8 @@ void SetHeaders(ScopedEnv & env, jobject const params, platform::HttpClient::Hea
   if (headers.empty())
     return;
 
-  static jmethodID const setHeaders = env->GetMethodID(
+  static jmethodID const setHeaders =
-      g_httpParamsClazz, "setHeaders", "([Lapp/organicmaps/sdk/util/KeyValue;)V");
+      env->GetMethodID(g_httpParamsClazz, "setHeaders", "([Lapp/organicmaps/sdk/util/KeyValue;)V");
 
   RethrowOnJniException(env);
 
@@ -115,8 +114,7 @@ void SetHeaders(ScopedEnv & env, jobject const params, platform::HttpClient::Hea
 
 void LoadHeaders(ScopedEnv & env, jobject const params, platform::HttpClient::Headers & headers)
 {
-  static jmethodID const getHeaders =
+  static jmethodID const getHeaders = env->GetMethodID(g_httpParamsClazz, "getHeaders", "()[Ljava/lang/Object;");
-      env->GetMethodID(g_httpParamsClazz, "getHeaders", "()[Ljava/lang/Object;");
 
   jni::ScopedLocalRef<jobjectArray> const headersArray(
       env.get(), static_cast<jobjectArray>(env->CallObjectMethod(params, getHeaders)));
@@ -134,8 +132,7 @@ class Ids
 public:
   explicit Ids(ScopedEnv & env)
   {
-    m_fieldIds =
+    m_fieldIds = {{"httpMethod", GetHttpParamsFieldId(env, "httpMethod")},
-    {{"httpMethod", GetHttpParamsFieldId(env, "httpMethod")},
                   {"inputFilePath", GetHttpParamsFieldId(env, "inputFilePath")},
                   {"outputFilePath", GetHttpParamsFieldId(env, "outputFilePath")},
                   {"cookies", GetHttpParamsFieldId(env, "cookies")},
@@ -173,8 +170,7 @@ bool HttpClient::RunHttpRequest()
   static Ids ids(env);
 
   // Create and fill request params.
-  jni::ScopedLocalRef<jstring> const jniUrl(env.get(),
+  jni::ScopedLocalRef<jstring> const jniUrl(env.get(), jni::ToJavaString(env.get(), m_urlRequested));
-                                            jni::ToJavaString(env.get(), m_urlRequested));
   if (jni::HandleJavaException(env.get()))
     return false;
 
@@ -190,14 +186,14 @@ bool HttpClient::RunHttpRequest()
   static jfieldID const dataField = env->GetFieldID(g_httpParamsClazz, "data", "[B");
   if (!m_bodyData.empty())
   {
-    jni::ScopedLocalRef<jbyteArray> const jniPostData(
+    jni::ScopedLocalRef<jbyteArray> const jniPostData(env.get(),
-        env.get(), env->NewByteArray(static_cast<jsize>(m_bodyData.size())));
+                                                      env->NewByteArray(static_cast<jsize>(m_bodyData.size())));
 
     if (jni::HandleJavaException(env.get()))
       return false;
 
     env->SetByteArrayRegion(jniPostData.get(), 0, static_cast<jsize>(m_bodyData.size()),
-                            reinterpret_cast<const jbyte *>(m_bodyData.data()));
+                            reinterpret_cast<jbyte const *>(m_bodyData.data()));
     if (jni::HandleJavaException(env.get()))
       return false;
 
@@ -216,8 +212,7 @@ bool HttpClient::RunHttpRequest()
     SetString(env, httpParamsObject.get(), ids.GetId("cookies"), m_cookies);
     SetBoolean(env, httpParamsObject.get(), ids.GetId("followRedirects"), m_followRedirects);
     SetBoolean(env, httpParamsObject.get(), ids.GetId("loadHeaders"), m_loadHeaders);
-    SetInt(env, httpParamsObject.get(), ids.GetId("timeoutMillisec"),
+    SetInt(env, httpParamsObject.get(), ids.GetId("timeoutMillisec"), static_cast<int>(m_timeoutSec * 1000));
-           static_cast<int>(m_timeoutSec * 1000));
 
     SetHeaders(env, httpParamsObject.get(), m_headers);
   }
@@ -226,12 +221,12 @@ bool HttpClient::RunHttpRequest()
     return false;
   }
 
-  static jmethodID const httpClientClassRun =
+  static jmethodID const httpClientClassRun = env->GetStaticMethodID(
-    env->GetStaticMethodID(g_httpClientClazz, "run",
+      g_httpClientClazz, "run",
       "(Lapp/organicmaps/sdk/util/HttpClient$Params;)Lapp/organicmaps/sdk/util/HttpClient$Params;");
 
-  jni::ScopedLocalRef<jobject> const response(env.get(), env->CallStaticObjectMethod(g_httpClientClazz,
+  jni::ScopedLocalRef<jobject> const response(
-                                              httpClientClassRun, httpParamsObject.get()));
+      env.get(), env->CallStaticObjectMethod(g_httpClientClazz, httpClientClassRun, httpParamsObject.get()));
   if (jni::HandleJavaException(env.get()))
     return false;
 
@@ -247,8 +242,8 @@ bool HttpClient::RunHttpRequest()
   }
 
   // dataField is already cached above.
-  jni::ScopedLocalRef<jbyteArray> const jniData(
+  jni::ScopedLocalRef<jbyteArray> const jniData(env.get(),
-      env.get(), static_cast<jbyteArray>(env->GetObjectField(response, dataField)));
+                                                static_cast<jbyteArray>(env->GetObjectField(response, dataField)));
   if (jni::HandleJavaException(env.get()))
     return false;
   if (jniData)
@@ -256,7 +251,7 @@ bool HttpClient::RunHttpRequest()
     jbyte * buffer = env->GetByteArrayElements(jniData.get(), nullptr);
     if (buffer)
     {
-      m_serverResponse.assign(reinterpret_cast<const char *>(buffer), env->GetArrayLength(jniData.get()));
+      m_serverResponse.assign(reinterpret_cast<char const *>(buffer), env->GetArrayLength(jniData.get()));
       env->ReleaseByteArrayElements(jniData.get(), buffer, JNI_ABORT);
     }
   }

android/sdk/src/main/cpp/app/organicmaps/sdk/util/Language.cpp

@@ -3,8 +3,8 @@
 
 extern "C"
 {
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_util_Language_nativeNormalize(JNIEnv * env, jclass type,
-Java_app_organicmaps_sdk_util_Language_nativeNormalize(JNIEnv *env, jclass type, jstring lang)
+                                                                                 jstring lang)
 {
   std::string locale = languages::Normalize(jni::ToNativeString(env, lang));
   return jni::ToJavaString(env, locale);

android/sdk/src/main/cpp/app/organicmaps/sdk/util/LogsManager.cpp

@@ -1,10 +1,11 @@
 #include <jni.h>
 #include "app/organicmaps/sdk/core/logging.hpp"
 
-extern "C" {
+extern "C"
-JNIEXPORT void JNICALL
+{
-Java_app_organicmaps_sdk_util_log_LogsManager_nativeToggleCoreDebugLogs(
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_log_LogsManager_nativeToggleCoreDebugLogs(JNIEnv * /*env*/,
-    JNIEnv * /*env*/, jclass /*clazz*/, jboolean enabled)
+                                                                                               jclass /*clazz*/,
+                                                                                               jboolean enabled)
 {
   jni::ToggleDebugLogs(enabled);
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/util/NetworkPolicy.cpp

@@ -4,8 +4,7 @@ namespace network_policy
 {
 bool GetNetworkPolicyStatus(JNIEnv * env, jobject obj)
 {
-  static jmethodID const networkPolicyCanUseMethod =
+  static jmethodID const networkPolicyCanUseMethod = jni::GetMethodID(env, obj, "canUseNetwork", "()Z");
-      jni::GetMethodID(env, obj, "canUseNetwork", "()Z");
   return env->CallBooleanMethod(obj, networkPolicyCanUseMethod);
 }
 

android/sdk/src/main/cpp/app/organicmaps/sdk/util/NetworkPolicy.hpp

@@ -4,4 +4,4 @@ namespace network_policy
 {
 bool GetNetworkPolicyStatus(JNIEnv * env, jobject obj);
 bool GetCurrentNetworkUsageStatus(JNIEnv * env);
-}
+}  // namespace network_policy

android/sdk/src/main/cpp/app/organicmaps/sdk/util/StringUtils.cpp

@@ -20,20 +20,21 @@ jobject MakeJavaPair(JNIEnv * env, std::string const & first, std::string const
 
 extern "C"
 {
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeIsHtml(JNIEnv * env, jclass thiz,
-Java_app_organicmaps_sdk_util_StringUtils_nativeIsHtml(JNIEnv * env, jclass thiz, jstring text)
+                                                                                  jstring text)
 {
   return strings::IsHTML(jni::ToNativeString(env, text));
 }
 
-JNIEXPORT jboolean JNICALL
+JNIEXPORT jboolean JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeContainsNormalized(JNIEnv * env, jclass thiz,
-Java_app_organicmaps_sdk_util_StringUtils_nativeContainsNormalized(JNIEnv * env, jclass thiz, jstring str, jstring substr)
+                                                                                              jstring str,
+                                                                                              jstring substr)
 {
   return search::ContainsNormalized(jni::ToNativeString(env, str), jni::ToNativeString(env, substr));
 }
 
-JNIEXPORT jobjectArray JNICALL
+JNIEXPORT jobjectArray JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeFilterContainsNormalized(
-Java_app_organicmaps_sdk_util_StringUtils_nativeFilterContainsNormalized(JNIEnv * env, jclass thiz, jobjectArray src, jstring jSubstr)
+    JNIEnv * env, jclass thiz, jobjectArray src, jstring jSubstr)
 {
   std::string const substr = jni::ToNativeString(env, jSubstr);
   int const length = env->GetArrayLength(src);
@@ -49,42 +50,41 @@ Java_app_organicmaps_sdk_util_StringUtils_nativeFilterContainsNormalized(JNIEnv
   return jni::ToJavaStringArray(env, filtered);
 }
 
-JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeFormatSpeed(
+JNIEXPORT jint JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeFormatSpeed(JNIEnv * env, jclass thiz,
-    JNIEnv * env, jclass thiz, jdouble metersPerSecond)
+                                                                                   jdouble metersPerSecond)
 {
   return measurement_utils::FormatSpeed(metersPerSecond, measurement_utils::GetMeasurementUnits());
 }
 
-JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeFormatSpeedAndUnits(
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeFormatSpeedAndUnits(JNIEnv * env, jclass thiz,
-    JNIEnv * env, jclass thiz, jdouble metersPerSecond)
+                                                                                              jdouble metersPerSecond)
 {
   auto const units = measurement_utils::GetMeasurementUnits();
   return MakeJavaPair(env, measurement_utils::FormatSpeedNumeric(metersPerSecond, units),
                       platform::GetLocalizedSpeedUnits(units));
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeFormatDistance(JNIEnv * env, jclass,
-Java_app_organicmaps_sdk_util_StringUtils_nativeFormatDistance(JNIEnv * env, jclass, jdouble distanceInMeters)
+                                                                                         jdouble distanceInMeters)
 {
   return ToJavaDistance(env, platform::Distance::CreateFormatted(distanceInMeters));
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeGetLocalizedDistanceUnits(JNIEnv * env,
-Java_app_organicmaps_sdk_util_StringUtils_nativeGetLocalizedDistanceUnits(JNIEnv * env, jclass)
+                                                                                                    jclass)
 {
   auto const localizedUnits = platform::GetLocalizedDistanceUnits();
   return MakeJavaPair(env, localizedUnits.m_high, localizedUnits.m_low);
 }
 
-JNIEXPORT jobject JNICALL
+JNIEXPORT jobject JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeGetLocalizedAltitudeUnits(JNIEnv * env,
-Java_app_organicmaps_sdk_util_StringUtils_nativeGetLocalizedAltitudeUnits(JNIEnv * env, jclass)
+                                                                                                    jclass)
 {
   auto const localizedUnits = platform::GetLocalizedAltitudeUnits();
   return MakeJavaPair(env, localizedUnits.m_high, localizedUnits.m_low);
 }
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jstring JNICALL Java_app_organicmaps_sdk_util_StringUtils_nativeGetLocalizedSpeedUnits(JNIEnv * env, jclass)
-Java_app_organicmaps_sdk_util_StringUtils_nativeGetLocalizedSpeedUnits(JNIEnv * env, jclass)
 {
   return jni::ToJavaString(env, platform::GetLocalizedSpeedUnits());
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/util/UiThread.cpp

@@ -4,8 +4,8 @@
 extern "C"
 {
 // static void nativeProcessTask(long taskPointer);
-JNIEXPORT void JNICALL
+JNIEXPORT void JNICALL Java_app_organicmaps_sdk_util_concurrency_UiThread_nativeProcessTask(JNIEnv * env, jclass clazz,
-Java_app_organicmaps_sdk_util_concurrency_UiThread_nativeProcessTask(JNIEnv * env, jclass clazz, jlong taskPointer)
+                                                                                            jlong taskPointer)
 {
   android::GuiThread::ProcessTask(taskPointer);
 }

android/sdk/src/main/cpp/app/organicmaps/sdk/vulkan/android_vulkan_context_factory.cpp

@@ -43,8 +43,7 @@ void AndroidVulkanContextFactory::SetVulkanSurface()
   createInfo.window = m_nativeWindow;
 
   VkResult statusCode;
-  statusCode = vkCreateAndroidSurfaceKHR(m_vulkanInstance, &createInfo, nullptr,
+  statusCode = vkCreateAndroidSurfaceKHR(m_vulkanInstance, &createInfo, nullptr, &m_surface);
-                                         &m_surface);
   if (statusCode != VK_SUCCESS)
   {
     LOG_ERROR_VK_CALL(vkCreateAndroidSurfaceKHR, statusCode);

dev_sandbox/imgui_renderer.cpp

@@ -12,8 +12,7 @@
 #include <cstring>
 #include <limits>
 
-ImguiRenderer::ImguiRenderer()
+ImguiRenderer::ImguiRenderer() : m_state(df::CreateRenderState(gpu::Program::ImGui, df::DepthLayer::GuiLayer))
-  : m_state(df::CreateRenderState(gpu::Program::ImGui, df::DepthLayer::GuiLayer))
 {
   m_state.SetDepthTestEnabled(false);
   m_state.SetBlending(dp::Blending(true));
@@ -91,8 +90,7 @@ void ImguiRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Tex
 
   gpu::ImGuiProgramParams const params{.m_projection = m_projection};
   context->PushDebugLabel("ImGui Rendering");
-  m_mesh->Render(context, gpuProgram, m_state, programManager->GetParamsSetter(), params,
+  m_mesh->Render(context, gpuProgram, m_state, programManager->GetParamsSetter(), params, [&, this]()
-                 [&, this]()
   {
     context->SetCullingEnabled(false);
     for (auto const & drawCall : dataBuffer.m_drawCalls)
@@ -209,7 +207,7 @@ void ImguiRenderer::UpdateBuffers()
 
     for (int cmdIndex = 0; cmdIndex < cmdList->CmdBuffer.Size; ++cmdIndex)
     {
-      const ImDrawCmd cmd = cmdList->CmdBuffer[cmdIndex];
+      ImDrawCmd const cmd = cmdList->CmdBuffer[cmdIndex];
       ImVec2 clipMin((cmd.ClipRect.x - clipOff.x) * clipScale.x, (cmd.ClipRect.y - clipOff.y) * clipScale.y);
       ImVec2 clipMax((cmd.ClipRect.z - clipOff.x) * clipScale.x, (cmd.ClipRect.w - clipOff.y) * clipScale.y);
       if (clipMin.x < 0.0f)

dev_sandbox/imgui_renderer.hpp

@@ -18,8 +18,7 @@ class ImguiRenderer
 {
 public:
   ImguiRenderer();
-  void Render(ref_ptr<dp::GraphicsContext> context, 
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::TextureManager> textureManager,
-              ref_ptr<dp::TextureManager> textureManager,
               ref_ptr<gpu::ProgramManager> programManager);
   void Update(std::function<void()> const & uiCallback);
   void Reset();

dev_sandbox/main.cpp

@@ -7,9 +7,9 @@
 
 #include "coding/reader.hpp"
 
-#include "base/math.hpp"
 #include "base/logging.hpp"
 #include "base/macros.hpp"
+#include "base/math.hpp"
 
 #include "std/target_os.hpp"
 
@@ -81,7 +81,10 @@ bool ValidateLogAbortLevel(char const * flagname, std::string const & value)
 
 bool const g_logAbortLevelDummy = gflags::RegisterFlagValidator(&FLAGS_log_abort_level, &ValidateLogAbortLevel);
 
-void errorCallback(int error, char const * description) { LOG(LERROR, ("GLFW (", error, "):", description)); }
+void errorCallback(int error, char const * description)
+{
+  LOG(LERROR, ("GLFW (", error, "):", description));
+}
 
 struct WindowHandlers
 {
@@ -143,7 +146,7 @@ void FormatMapSize(uint64_t sizeInBytes, std::string & units, size_t & sizeToDow
 
 std::string_view GetMyPoisitionText(location::EMyPositionMode mode)
 {
-  switch(mode)
+  switch (mode)
   {
   case location::EMyPositionMode::PendingPosition: return "Pending";
   case location::EMyPositionMode::NotFollowNoPosition: return "No position";
@@ -157,9 +160,12 @@ std::string_view GetMyPoisitionText(location::EMyPositionMode mode)
 dp::ApiVersion GetApiVersion(char const * apiLabel)
 {
   std::string_view v(apiLabel);
-  if (v == "Metal") return dp::ApiVersion::Metal;
+  if (v == "Metal")
-  if (v == "Vulkan") return dp::ApiVersion::Vulkan;
+    return dp::ApiVersion::Metal;
-  if (v == "OpenGL") return  dp::ApiVersion::OpenGLES3;
+  if (v == "Vulkan")
+    return dp::ApiVersion::Vulkan;
+  if (v == "OpenGL")
+    return dp::ApiVersion::OpenGLES3;
   return dp::ApiVersion::Invalid;
 }
 
@@ -231,17 +237,14 @@ int main(int argc, char * argv[])
   // Init GLFW.
   glfwSetErrorCallback(errorCallback);
   if (!glfwInit())
-  {
     return -1;
-  }
   glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
 #if defined(OMIM_OS_WINDOWS)
   glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE);
 #endif
   auto monitor = glfwGetPrimaryMonitor();
   auto mode = glfwGetVideoMode(monitor);
-  GLFWwindow * window =
+  GLFWwindow * window = glfwCreateWindow(mode->width, mode->height, "Developer Render Sandbox", nullptr, nullptr);
-      glfwCreateWindow(mode->width, mode->height, "Developer Render Sandbox", nullptr, nullptr);
   int fbWidth = 0, fbHeight = 0;
   glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
   float xs = 1.0f, ys = 1.0f;
@@ -277,10 +280,8 @@ int main(int argc, char * argv[])
       .m_visualScale = visualScale,
       .m_surfaceWidth = fbWidth,
       .m_surfaceHeight = fbHeight,
-      .m_renderInjectionHandler = [&](ref_ptr<dp::GraphicsContext> context,
+      .m_renderInjectionHandler = [&](ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::TextureManager> textureManager,
-                                      ref_ptr<dp::TextureManager> textureManager,
+                                      ref_ptr<gpu::ProgramManager> programManager, bool shutdown)
-                                      ref_ptr<gpu::ProgramManager> programManager,
-                                      bool shutdown)
   {
     if (shutdown)
       imguiRenderer.Reset();
@@ -360,10 +361,8 @@ int main(int argc, char * argv[])
       framework.OnSize(fbWidth, fbHeight);
     }
   };
-  glfwSetWindowContentScaleCallback(window, [](GLFWwindow *, float xscale, float yscale)
+  glfwSetWindowContentScaleCallback(
-  {
+      window, [](GLFWwindow *, float xscale, float yscale) { handlers.onContentScale(xscale, yscale); });
-    handlers.onContentScale(xscale, yscale);
-  });
 
   // Location handler
   std::optional<ms::LatLon> lastLatLon;
@@ -384,10 +383,8 @@ int main(int argc, char * argv[])
                             .m_horizontalAccuracy = 10,
                             .m_bearing = bearingEnabled ? bearing : -1.0f});
       if (bearingEnabled)
-      {
         framework.OnCompassUpdate(location::CompassInfo{.m_bearing = math::DegToRad(bearing)});
     }
-    }
   };
 
   // Download maps handler
@@ -440,12 +437,10 @@ int main(int argc, char * argv[])
     // Storage also calls notifications for parents, but we are interested in leafs only.
     if (framework.GetStorage().IsLeaf(countryId))
       onCountryChanged(countryId);
-      },
+  }, [&](storage::CountryId const & countryId, downloader::Progress const & progress)
-      [&](storage::CountryId const & countryId, downloader::Progress const & progress)
   {
     std::stringstream str;
-        str << "Downloading (" << countryId << ") " << (progress.m_bytesDownloaded * 100 / progress.m_bytesTotal)
+    str << "Downloading (" << countryId << ") " << (progress.m_bytesDownloaded * 100 / progress.m_bytesTotal) << "%";
-            << "%";
     downloadStatusLabel = str.str();
     framework.MakeFrameActive();
   });
@@ -491,8 +486,7 @@ int main(int argc, char * argv[])
       touchMods = 0;
     }
   };
-  glfwSetMouseButtonCallback(window,
+  glfwSetMouseButtonCallback(window, [](GLFWwindow * wnd, int button, int action, int mods)
-                             [](GLFWwindow * wnd, int button, int action, int mods)
   {
     double x, y;
     glfwGetCursorPos(wnd, &x, &y);
@@ -509,19 +503,13 @@ int main(int argc, char * argv[])
       framework.MakeFrameActive();
 
     if (touchActive)
-    {
 #if defined(OMIM_OS_MAC)
       x *= visualScale;
     y *= visualScale;
 #endif
-      framework.TouchEvent(
+    framework.TouchEvent(GetTouchEvent(framework, x, y, touchMods, df::TouchEvent::TOUCH_MOVE));
-          GetTouchEvent(framework, x, y, touchMods, df::TouchEvent::TOUCH_MOVE));
-    }
   };
-  glfwSetCursorPosCallback(window, [](GLFWwindow *, double x, double y)
+  glfwSetCursorPosCallback(window, [](GLFWwindow *, double x, double y) { handlers.onMouseMove(x, y); });
-  {
-    handlers.onMouseMove(x, y);
-  });
 
   // Handle scroll.
   handlers.onScroll = [&](double x, double y, double xOffset, double yOffset)
@@ -543,8 +531,7 @@ int main(int argc, char * argv[])
     double const factor = yOffset * kSensitivity;
     framework.Scale(exp(factor), m2::PointD(x, y), false);
   };
-  glfwSetScrollCallback(window,
+  glfwSetScrollCallback(window, [](GLFWwindow * wnd, double xoffset, double yoffset)
-                        [](GLFWwindow * wnd, double xoffset, double yoffset)
   {
     double x, y;
     glfwGetCursorPos(wnd, &x, &y);
@@ -554,9 +541,7 @@ int main(int argc, char * argv[])
   // Keys.
   handlers.onKeyboardButton = [&](int key, int scancode, int action, int mods) {};
   glfwSetKeyCallback(window, [](GLFWwindow *, int key, int scancode, int action, int mods)
-  {
+  { handlers.onKeyboardButton(key, scancode, action, mods); });
-    handlers.onKeyboardButton(key, scancode, action, mods);
-  });
 
   // imGui UI
   bool enableDebugRectRendering = false;
@@ -569,12 +554,9 @@ int main(int argc, char * argv[])
     // Drape controls
     char const * apiLabels[] = {
 #if defined(OMIM_OS_MAC)
-      "Metal",
+        "Metal", "Vulkan", "OpenGL"
-      "Vulkan",
-      "OpenGL"
 #elif defined(OMIM_OS_LINUX)
-      "Vulkan",
+        "Vulkan", "OpenGL"
-      "OpenGL"
 #endif
     };
     static int currentAPI = 0;
@@ -656,7 +638,7 @@ int main(int argc, char * argv[])
 
     // Render imGui UI
     ImGui_ImplGlfw_NewFrame();
-    ImGuiIO& io = ImGui::GetIO();
+    ImGuiIO & io = ImGui::GetIO();
 #if defined(OMIM_OS_LINUX)
     // Apply correct visual scale on Linux
     // In glfw for Linux, window size and framebuffer size are the same,

dev_sandbox/main_linux.cpp

@@ -8,8 +8,8 @@
 #define GLFW_EXPOSE_NATIVE_X11
 #include <GLFW/glfw3native.h>
 
-#include <dlfcn.h>
 #include <X11/X.h>
+#include <dlfcn.h>
 
 #include <vulkan_wrapper.h>
 // Workaround for TestFunction::Always compilation issue:
@@ -104,13 +104,13 @@ typedef XID GLXPbuffer;
 typedef struct __GLXFBConfig * GLXFBConfig;
 typedef void (*__GLXextproc)(void);
 
-typedef __GLXextproc (*PFNGLXGETPROCADDRESSPROC)(const GLubyte * procName);
+typedef __GLXextproc (*PFNGLXGETPROCADDRESSPROC)(GLubyte const * procName);
 
 typedef int (*PFNXFREE)(void *);
-typedef GLXFBConfig * (*PFNGLXCHOOSEFBCONFIGPROC)(Display *, int, const int *, int *);
+typedef GLXFBConfig * (*PFNGLXCHOOSEFBCONFIGPROC)(Display *, int, int const *, int *);
-typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARB)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
+typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARB)(Display *, GLXFBConfig, GLXContext, Bool, int const *);
 typedef void (*PFNGLXDESTROYCONTEXT)(Display *, GLXContext);
-typedef GLXPbuffer (*PFNGLXCREATEPBUFFERPROC)(Display *, GLXFBConfig, const int *);
+typedef GLXPbuffer (*PFNGLXCREATEPBUFFERPROC)(Display *, GLXFBConfig, int const *);
 typedef void (*PFNGLXDESTROYPBUFFER)(Display *, GLXPbuffer);
 typedef Bool (*PFNGLXMAKECURRENTPROC)(Display *, GLXDrawable, GLXContext);
 typedef void (*PFNGLXSWAPBUFFERSPROC)(Display *, GLXDrawable);
@@ -129,10 +129,8 @@ struct GLXFunctions
     {
       m_module = dlopen(lib, RTLD_LAZY | RTLD_LOCAL);
       if (m_module)
-      {
         break;
     }
-    }
 
     CHECK(m_module != nullptr, ("Failed to initialize GLX"));
 
@@ -154,10 +152,8 @@ struct GLXFunctions
   ~GLXFunctions()
   {
     if (m_module)
-    {
       dlclose(m_module);
   }
-  }
 
   PFNXFREE XFree = nullptr;
 
@@ -201,30 +197,41 @@ class LinuxGLContext : public dp::OGLContext
 public:
   LinuxGLContext(GLXFunctions const & glx, Display * display, Window window, LinuxGLContext * contextToShareWith,
                  bool usePixelBuffer)
-    : m_glx(glx), m_display(display), m_window(window)
+    : m_glx(glx)
+    , m_display(display)
+    , m_window(window)
   {
-    int visualAttribs[] = {
+    int visualAttribs[] = {GLX_DOUBLEBUFFER,
-      GLX_DOUBLEBUFFER, True,
+                           True,
-      GLX_RENDER_TYPE, GLX_RGBA_BIT,
+                           GLX_RENDER_TYPE,
-      GLX_DRAWABLE_TYPE, (usePixelBuffer ? GLX_PBUFFER_BIT : GLX_WINDOW_BIT),
+                           GLX_RGBA_BIT,
-      GLX_RED_SIZE, 8,
+                           GLX_DRAWABLE_TYPE,
-      GLX_GREEN_SIZE, 8,
+                           (usePixelBuffer ? GLX_PBUFFER_BIT : GLX_WINDOW_BIT),
-      GLX_BLUE_SIZE, 8,
+                           GLX_RED_SIZE,
-      GLX_ALPHA_SIZE, 8,
+                           8,
-      GLX_DEPTH_SIZE, 24,
+                           GLX_GREEN_SIZE,
-      GLX_STENCIL_SIZE, 8,
+                           8,
-      None
+                           GLX_BLUE_SIZE,
-    };
+                           8,
-    int contextAttribs[] = {
+                           GLX_ALPHA_SIZE,
-      GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                           8,
-      GLX_CONTEXT_MAJOR_VERSION_ARB, 4, 
+                           GLX_DEPTH_SIZE,
-      GLX_CONTEXT_MINOR_VERSION_ARB, 1,
+                           24,
+                           GLX_STENCIL_SIZE,
+                           8,
+                           None};
+    int contextAttribs[] = {GLX_CONTEXT_PROFILE_MASK_ARB,
+                            GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
+                            GLX_CONTEXT_MAJOR_VERSION_ARB,
+                            4,
+                            GLX_CONTEXT_MINOR_VERSION_ARB,
+                            1,
                             None};
     int fbcount = 0;
     if (GLXFBConfig * config = m_glx.glXChooseFBConfig(display, DefaultScreen(display), visualAttribs, &fbcount))
     {
-      m_context =
+      m_context = m_glx.glXCreateContextAttribsARB(
-          m_glx.glXCreateContextAttribsARB(display, config[0], contextToShareWith ? contextToShareWith->m_context : 0, True, contextAttribs);
+          display, config[0], contextToShareWith ? contextToShareWith->m_context : 0, True, contextAttribs);
       CHECK(m_context != nullptr, ("Failed to create GLX context"));
 
       if (usePixelBuffer)
@@ -368,9 +375,7 @@ drape_ptr<dp::GraphicsContextFactory> CreateContextFactory(GLFWwindow * window,
   }
 
   if (api == dp::ApiVersion::OpenGLES3)
-  {
     return make_unique_dp<LinuxContextFactory>(glfwGetX11Display(), glfwGetX11Window(window));
-  }
 
   ASSERT(false, ("API is not available yet"));
   return nullptr;

generator/address_enricher.cpp

@@ -34,14 +34,12 @@ std::pair<uint64_t, uint64_t> AddressEnricher::RawEntryBase::GetHNRange() const
   if (f.m_type != Token::TYPE_NUMBER || t.m_type != Token::TYPE_NUMBER)
     return kInvalidRange;
 
-  return { ToUInt(f.m_value), ToUInt(t.m_value) };
+  return {ToUInt(f.m_value), ToUInt(t.m_value)};
 }
 
 std::string DebugPrint(AddressEnricher::Stats const & s)
 {
-  return
+  return "{ m_noStreet = " + std::to_string(s.m_noStreet) + "; m_existInterpol = " + std::to_string(s.m_existInterpol) +
-    "{ m_noStreet = " + std::to_string(s.m_noStreet) +
-    "; m_existInterpol = " + std::to_string(s.m_existInterpol) +
          "; m_existSingle = " + std::to_string(s.m_existSingle) +
          "; m_enoughAddrs = " + std::to_string(s.m_enoughAddrs) +
          "; m_addedSingle = " + std::to_string(s.m_addedSingle) +
@@ -49,7 +47,6 @@ std::string DebugPrint(AddressEnricher::Stats const & s)
          "; m_addedInterpol = " + std::to_string(s.m_addedInterpol) + " }";
 }
 
-
 AddressEnricher::AddressEnricher()
 {
   auto const & cl = classif();
@@ -223,7 +220,7 @@ AddressEnricher::FoundT AddressEnricher::Match(Entry & e) const
   std::vector<m2::ParametrizedSegment<m2::PointD>> eSegs;
   eSegs.reserve(e.m_points.size() - 1);
   for (size_t i = 1; i < e.m_points.size(); ++i)
-    eSegs.emplace_back(e.m_points[i-1], e.m_points[i]);
+    eSegs.emplace_back(e.m_points[i - 1], e.m_points[i]);
 
   /// @todo Check nodes distance for now. Should make more honest algo.
   auto const isClose = [&e, &eSegs](feature::FeatureBuilder const & fb)
@@ -237,9 +234,7 @@ AddressEnricher::FoundT AddressEnricher::Match(Entry & e) const
 
       auto const ll = mercator::ToLatLon(p);
       auto const check = [&ll](m2::PointD const & p)
-      {
+      { return ms::DistanceOnEarth(ll, mercator::ToLatLon(p)) < kDistanceThresholdM; };
-        return ms::DistanceOnEarth(ll, mercator::ToLatLon(p)) < kDistanceThresholdM;
-      };
 
       if (!eSegs.empty())
       {
@@ -323,7 +318,7 @@ AddressEnricher::FoundT AddressEnricher::Match(Entry & e) const
       auto const & geom = fb.GetOuterGeometry();
       for (size_t i = 1; i < geom.size(); ++i)
       {
-        m2::ParametrizedSegment<m2::PointD> seg(geom[i-1], geom[i]);
+        m2::ParametrizedSegment<m2::PointD> seg(geom[i - 1], geom[i]);
         /// @todo Calculate e.m_points LL once?
         for (auto const & p : e.m_points)
           if (mercator::DistanceOnEarth(p, seg.ClosestPointTo(p)) < kDistanceThresholdM)
@@ -349,8 +344,8 @@ AddressEnricher::FoundT AddressEnricher::Match(Entry & e) const
         size_t const i = hnRange.find(':');
         CHECK(i != std::string::npos, (hnRange));
         uint64_t left, right;
-        CHECK(strings::to_uint(hnRange.substr(0, i), left) &&
+        CHECK(strings::to_uint(hnRange.substr(0, i), left) && strings::to_uint(hnRange.substr(i + 1), right),
-              strings::to_uint(hnRange.substr(i + 1), right), (hnRange));
+              (hnRange));
 
         res.interpol = !(left >= range.second || right <= range.first);
       }

generator/address_enricher.hpp

@@ -32,7 +32,8 @@ public:
     std::pair<uint64_t, uint64_t> GetHNRange() const;
     /// @}
 
-    template <class TSink> void Save(TSink & sink) const
+    template <class TSink>
+    void Save(TSink & sink) const
     {
       rw::Write(sink, m_from);
       rw::Write(sink, m_to);
@@ -42,7 +43,8 @@ public:
       WriteToSink(sink, static_cast<uint8_t>(m_interpol));
     }
 
-    template <class TSource> void Load(TSource & src)
+    template <class TSource>
+    void Load(TSource & src)
     {
       rw::Read(src, m_from);
       rw::Read(src, m_to);
@@ -62,7 +64,7 @@ public:
 
   void AddSrc(feature::FeatureBuilder && fb);
 
-  using TFBCollectFn = std::function<void (feature::FeatureBuilder &&)>;
+  using TFBCollectFn = std::function<void(feature::FeatureBuilder &&)>;
   void ProcessRawEntries(std::string const & path, TFBCollectFn const & fn);
 
   // Public for tests.

generator/address_parser/address_parser_tests/parser_tests.cpp

@@ -25,7 +25,9 @@ UNIT_TEST(TigerParser_Smoke)
   TEST(tiger::ParseLine("9587;9619;all;;Platte;MO;64152;LINESTRING(-94.691917 39.210393,-94.692370 39.210351)", e), ());
 
   e = {};
-  TEST(tiger::ParseLine("698;600;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.970484 39.464604,-77.970540 39.464630)", e), ());
+  TEST(tiger::ParseLine("698;600;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.970484 39.464604,-77.970540 39.464630)",
+                        e),
+       ());
   TEST_EQUAL(e.m_from, "600", ());
   TEST_EQUAL(e.m_to, "698", ());
   TEST_EQUAL(e.m_street, "Boston St", ());
@@ -33,10 +35,14 @@ UNIT_TEST(TigerParser_Smoke)
   TEST_EQUAL(e.m_interpol, feature::InterpolType::Any, ());
   TEST_EQUAL(e.m_geom.size(), 1, ());
 
-  TEST(ms::LatLon((39.464604 + 39.464630) / 2.0, (-77.970484 -77.970540) / 2.0).EqualDxDy(e.m_geom.back(), kEpsLL), ());
+  TEST(ms::LatLon((39.464604 + 39.464630) / 2.0, (-77.970484 - 77.970540) / 2.0).EqualDxDy(e.m_geom.back(), kEpsLL),
+       ());
 
   e = {};
-  TEST(tiger::ParseLine("798;700;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.968929 39.463906,-77.969118 39.463990,-77.969427 39.464129,-77.969946 39.464353,-77.970027 39.464389)", e), ());
+  TEST(tiger::ParseLine("798;700;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.968929 39.463906,-77.969118 "
+                        "39.463990,-77.969427 39.464129,-77.969946 39.464353,-77.970027 39.464389)",
+                        e),
+       ());
   TEST_EQUAL(e.m_from, "700", ());
   TEST_EQUAL(e.m_to, "798", ());
   TEST_EQUAL(e.m_street, "Boston St", ());
@@ -47,7 +53,11 @@ UNIT_TEST(TigerParser_Smoke)
   TEST(ms::LatLon(39.463906, -77.968929).EqualDxDy(e.m_geom.back(), kEpsLL), ());
   TEST(ms::LatLon(39.464389, -77.970027).EqualDxDy(e.m_geom.front(), kEpsLL), ());
 
-  TEST(tiger::ParseLine("0;98;even;Austin Ln;Mifflin;PA;17044;LINESTRING(-77.634119 40.597239,-77.634200 40.597288,-77.634679 40.598169,-77.634835 40.598393,-77.635116 40.598738,-77.635518 40.599388,-77.635718 40.599719,-77.635833 40.599871,-77.635856 40.599920)", e), ());
+  TEST(tiger::ParseLine("0;98;even;Austin Ln;Mifflin;PA;17044;LINESTRING(-77.634119 40.597239,-77.634200 "
+                        "40.597288,-77.634679 40.598169,-77.634835 40.598393,-77.635116 40.598738,-77.635518 "
+                        "40.599388,-77.635718 40.599719,-77.635833 40.599871,-77.635856 40.599920)",
+                        e),
+       ());
   TEST_EQUAL(e.m_from, "0", ());
   TEST_EQUAL(e.m_to, "98", ());
 }
@@ -55,6 +65,7 @@ UNIT_TEST(TigerParser_Smoke)
 class TmpDir
 {
   std::string const m_path = "./addrs";
+
 public:
   std::string const & Get() const { return m_path; }
 
@@ -63,10 +74,7 @@ public:
     (void)Platform::RmDirRecursively(m_path);
     TEST(Platform::MkDirChecked(m_path), ());
   }
-  ~TmpDir()
+  ~TmpDir() { TEST(Platform::RmDirRecursively(m_path), ()); }
-  {
-    TEST(Platform::RmDirRecursively(m_path), ());
-  }
 };
 
 UNIT_TEST(Processor_Smoke)
@@ -160,7 +168,9 @@ UNIT_CLASS_TEST(TestFixture, Generator_Smoke)
 {
   std::stringstream ss;
   ss << "698;600;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.970484 39.464604,-77.970540 39.464630)" << "\n"
-     << "798;700;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.968929 39.463906,-77.969118 39.463990,-77.969427 39.464129,-77.969946 39.464353,-77.970027 39.464389)" << "\n";
+     << "798;700;all;Boston St;Berkeley;WV;25401;LINESTRING(-77.968929 39.463906,-77.969118 39.463990,-77.969427 "
+        "39.464129,-77.969946 39.464353,-77.970027 39.464389)"
+     << "\n";
 
   Parse(ss);
 
@@ -170,7 +180,8 @@ UNIT_CLASS_TEST(TestFixture, Generator_Smoke)
 UNIT_CLASS_TEST(TestFixture, Generator_Filter_SF1)
 {
   std::stringstream ss;
-  ss << "601;699;all;Francisco St;San Francisco;CA;94133;LINESTRING(-122.416189 37.804256,-122.416526 37.804215)" << "\n";
+  ss << "601;699;all;Francisco St;San Francisco;CA;94133;LINESTRING(-122.416189 37.804256,-122.416526 37.804215)"
+     << "\n";
 
   Parse(ss);
 
@@ -190,8 +201,10 @@ UNIT_CLASS_TEST(TestFixture, Generator_Filter_NY)
 UNIT_CLASS_TEST(TestFixture, Generator_Filter_SF2)
 {
   std::stringstream ss;
-  ss << "744;752;all;Francisco St;San Francisco;CA;94133;LINESTRING(-122.417593 37.804248,-122.417686 37.804236)" << "\n"
+  ss << "744;752;all;Francisco St;San Francisco;CA;94133;LINESTRING(-122.417593 37.804248,-122.417686 37.804236)"
-     << "754;798;even;Francisco St;San Francisco;CA;94133;LINESTRING(-122.417933 37.804205,-122.418204 37.804171)" << "\n";
+     << "\n"
+     << "754;798;even;Francisco St;San Francisco;CA;94133;LINESTRING(-122.417933 37.804205,-122.418204 37.804171)"
+     << "\n";
 
   Parse(ss);
 
@@ -201,8 +214,12 @@ UNIT_CLASS_TEST(TestFixture, Generator_Filter_SF2)
 UNIT_CLASS_TEST(TestFixture, Generator_Street_Name)
 {
   std::stringstream ss;
-  ss << "599;501;odd;Seventh St;Marshall;MN;56757;LINESTRING(-96.878165 48.451707,-96.878047 48.451722,-96.877150 48.451844,-96.877034 48.451860)" << "\n"
+  ss << "599;501;odd;Seventh St;Marshall;MN;56757;LINESTRING(-96.878165 48.451707,-96.878047 48.451722,-96.877150 "
-     << "598;500;even;Seventh St;Marshall;MN;56757;LINESTRING(-96.878214 48.451868,-96.878097 48.451884,-96.877200 48.452006,-96.877084 48.452022)" << "\n";
+        "48.451844,-96.877034 48.451860)"
+     << "\n"
+     << "598;500;even;Seventh St;Marshall;MN;56757;LINESTRING(-96.878214 48.451868,-96.878097 48.451884,-96.877200 "
+        "48.452006,-96.877084 48.452022)"
+     << "\n";
 
   Parse(ss);
 

generator/address_parser/parser_tool.cpp

@@ -8,16 +8,15 @@
 
 #include <iostream>
 
-
 DEFINE_string(data_path, "./data", "Data path with 'borders' folder inside");
 DEFINE_string(output_path, "", "Output files path");
 DEFINE_uint64(threads_count, 0, "Desired number of threads. 0 - number of threads is set automatically");
 
-
 MAIN_WITH_ERROR_HANDLING([](int argc, char ** argv)
 {
   std::string usage("Tiger addresses processor. Sample usage:\n");
-  gflags::SetUsageMessage(usage + "tar -xOzf tiger-nominatim-preprocessed-latest.csv.tar.gz | " + argv[0] + " --output_path=... ");
+  gflags::SetUsageMessage(usage + "tar -xOzf tiger-nominatim-preprocessed-latest.csv.tar.gz | " + argv[0] +
+                          " --output_path=... ");
 
   gflags::ParseCommandLineFlags(&argc, &argv, true);
 

generator/address_parser/processor.cpp

@@ -10,7 +10,6 @@
 
 #include "defines.hpp"
 
-
 namespace addr_generator
 {
 
@@ -18,8 +17,7 @@ Processor::Processor(std::string const & dataPath, std::string const & outputPat
   : m_affiliation(dataPath, true /* haveBordersForWholeWorld */)
   , m_workers(numThreads)
   , m_outputPath(outputPath)
-{
+{}
-}
 
 FileWriter & Processor::GetWriter(std::string const & country)
 {

generator/address_parser/tiger_parser.cpp

@@ -30,7 +30,7 @@ void ParseGeometry(std::string_view s, std::vector<ms::LatLon> & geom)
     CHECK(i != std::string_view::npos, (s));
 
     CHECK(to_double(s.substr(0, i), last.m_lon), (s));
-    CHECK(to_double(s.substr(i+1), last.m_lat), (s));
+    CHECK(to_double(s.substr(i + 1), last.m_lat), (s));
 
     if (!skipPoint())
       geom.push_back(last);
@@ -42,7 +42,7 @@ void ParseGeometry(std::string_view s, std::vector<ms::LatLon> & geom)
     if (geom.size() == 1)
     {
       // Set one middle point address.
-      back = ms::LatLon{ (back.m_lat + last.m_lat) / 2.0, (back.m_lon + last.m_lon) / 2.0 };
+      back = ms::LatLon{(back.m_lat + last.m_lat) / 2.0, (back.m_lon + last.m_lon) / 2.0};
     }
     else
     {
@@ -71,15 +71,21 @@ bool ParseLine(std::string_view line, AddressEntry & e)
   if (std::count(line.begin(), line.end(), ';') != 7)
     return false;
 
-  TokenizeIterator<SimpleDelimiter, std::string_view::const_iterator, true /* KeepEmptyTokens */> it(
+  TokenizeIterator<SimpleDelimiter, std::string_view::const_iterator, true /* KeepEmptyTokens */> it(line.begin(),
-      line.begin(), line.end(), ";");
+                                                                                                     line.end(), ";");
 
-  e.m_from = *it; ++it;
+  e.m_from = *it;
-  e.m_to = *it; ++it;
+  ++it;
-  e.m_interpol = ParseInterpolation(*it); ++it;
+  e.m_to = *it;
-  e.m_street = *it; ++it;
+  ++it;
-  ++it; ++it;
+  e.m_interpol = ParseInterpolation(*it);
-  e.m_postcode = *it; ++it;
+  ++it;
+  e.m_street = *it;
+  ++it;
+  ++it;
+  ++it;
+  e.m_postcode = *it;
+  ++it;
   ParseGeometry(*it, e.m_geom);
 
   if (e.m_interpol == feature::InterpolType::None || e.m_geom.empty())

generator/addresses_collector.cpp

@@ -24,7 +24,7 @@ uint64_t GetOsmID(FeatureBuilder const & fb)
 AddressesHolder::AddressInfo FromFB(FeatureBuilder const & fb)
 {
   auto const & params = fb.GetParams();
-  return { params.house.Get(), std::string(params.GetStreet()), std::string(params.GetPostcode()), {} };
+  return {params.house.Get(), std::string(params.GetStreet()), std::string(params.GetPostcode()), {}};
 }
 
 // Current stats:
@@ -37,7 +37,6 @@ void LogWarning(std::string const & msg, uint64_t id)
 }
 }  // namespace
 
-
 std::string AddressesHolder::AddressInfo::FormatRange() const
 {
   if (m_house.empty() || m_house2.empty())
@@ -81,7 +80,6 @@ std::string AddressesHolder::AddressInfo::FormatRange() const
   }
 }
 
-
 void AddressesHolder::Add(FeatureBuilder const & fb)
 {
   CHECK(fb.IsPoint(), ());
@@ -160,11 +158,7 @@ void AddressesHolder::Deserialize(std::string const & filePath)
   }
 }
 
-
+AddressesCollector::AddressesCollector(std::string const & filename) : CollectorInterface(filename) {}
-AddressesCollector::AddressesCollector(std::string const & filename)
-  : CollectorInterface(filename)
-{
-}
 
 std::shared_ptr<CollectorInterface> AddressesCollector::Clone(IDRInterfacePtr const & cache) const
 {

generator/affiliation.cpp

@@ -9,10 +9,9 @@
 
 #include <functional>
 
-#include "std/boost_geometry.hpp"
-#include <boost/geometry/geometries/register/ring.hpp>
 #include <boost/geometry/geometries/register/point.hpp>
-
+#include <boost/geometry/geometries/register/ring.hpp>
+#include "std/boost_geometry.hpp"
 
 BOOST_GEOMETRY_REGISTER_POINT_2D(m2::PointD, double, boost::geometry::cs::cartesian, x, y)
 BOOST_GEOMETRY_REGISTER_RING(std::vector<m2::PointD>)
@@ -34,16 +33,16 @@ template <typename T>
 m2::RectD GetLimitRect(T && t)
 {
   using Type = RemoveCvrefT<T>;
-  if constexpr(std::is_same_v<Type, FeatureBuilder>)
+  if constexpr (std::is_same_v<Type, FeatureBuilder>)
     return t.GetLimitRect();
-  if constexpr(std::is_same_v<Type, std::vector<m2::PointD>>)
+  if constexpr (std::is_same_v<Type, std::vector<m2::PointD>>)
   {
     m2::RectD r;
     for (auto const & p : t)
       r.Add(p);
     return r;
   }
-  if constexpr(std::is_same_v<Type, m2::PointD>)
+  if constexpr (std::is_same_v<Type, m2::PointD>)
     return m2::RectD(t, t);
 
   UNREACHABLE();
@@ -53,11 +52,11 @@ template <typename T, typename F>
 bool ForAnyPoint(T && t, F && f)
 {
   using Type = RemoveCvrefT<T>;
-  if constexpr(std::is_same_v<Type, FeatureBuilder>)
+  if constexpr (std::is_same_v<Type, FeatureBuilder>)
     return t.ForAnyPoint(f);
-  if constexpr(std::is_same_v<Type, std::vector<m2::PointD>>)
+  if constexpr (std::is_same_v<Type, std::vector<m2::PointD>>)
     return base::AnyOf(t, f);
-  if constexpr(std::is_same_v<Type, m2::PointD>)
+  if constexpr (std::is_same_v<Type, m2::PointD>)
     return f(t);
 
   UNREACHABLE();
@@ -67,9 +66,9 @@ template <typename T, typename F>
 void ForEachPoint(T && t, F && f)
 {
   using Type = RemoveCvrefT<T>;
-  if constexpr(std::is_same_v<Type, FeatureBuilder>)
+  if constexpr (std::is_same_v<Type, FeatureBuilder>)
     t.ForEachPoint(std::forward<F>(f));
-  else if constexpr(std::is_same_v<Type, m2::PointD>)
+  else if constexpr (std::is_same_v<Type, m2::PointD>)
     f(std::forward<T>(t));
   else
     UNREACHABLE();
@@ -77,16 +76,13 @@ void ForEachPoint(T && t, F && f)
 
 // An implementation for CountriesFilesAffiliation class.
 template <typename T>
-std::vector<std::string> GetAffiliations(T const & t,
+std::vector<std::string> GetAffiliations(T const & t, borders::CountryPolygonsCollection const & countryPolygonsTree,
-                                         borders::CountryPolygonsCollection const & countryPolygonsTree,
                                          bool haveBordersForWholeWorld)
 {
   std::vector<std::string> countries;
   std::vector<std::reference_wrapper<borders::CountryPolygons const>> countriesContainer;
-  countryPolygonsTree.ForEachCountryInRect(GetLimitRect(t), [&](auto const & countryPolygons)
+  countryPolygonsTree.ForEachCountryInRect(
-  {
+      GetLimitRect(t), [&](auto const & countryPolygons) { countriesContainer.emplace_back(countryPolygons); });
-    countriesContainer.emplace_back(countryPolygons);
-  });
 
   // todo(m.andrianov): We need to explore this optimization better. There is a hypothesis: some
   // elements belong to a rectangle, but do not belong to the exact boundary.
@@ -99,10 +95,7 @@ std::vector<std::string> GetAffiliations(T const & t,
 
   for (borders::CountryPolygons const & countryPolygons : countriesContainer)
   {
-    auto const need = ForAnyPoint(t, [&](auto const & point)
+    auto const need = ForAnyPoint(t, [&](auto const & point) { return countryPolygons.Contains(point); });
-    {
-      return countryPolygons.Contains(point);
-    });
 
     if (need)
       countries.emplace_back(countryPolygons.GetName());
@@ -119,24 +112,20 @@ CountriesFilesIndexAffiliation::Box MakeBox(m2::RectD const & rect)
   return {rect.LeftBottom(), rect.RightTop()};
 }
 
-std::optional<std::string> IsOneCountryForLimitRect(m2::RectD const & limitRect,
+std::optional<std::string> IsOneCountryForLimitRect(m2::RectD const & limitRect, IndexSharedPtr const & index)
-                                                    IndexSharedPtr const & index)
 {
   borders::CountryPolygons const * country = nullptr;
   std::vector<CountriesFilesIndexAffiliation::Value> values;
   auto const bbox = MakeBox(limitRect);
-  boost::geometry::index::query(*index, boost::geometry::index::covers(bbox),
+  boost::geometry::index::query(*index, boost::geometry::index::covers(bbox), std::back_inserter(values));
-                                std::back_inserter(values));
   for (auto const & v : values)
   {
     for (borders::CountryPolygons const & c : v.second)
-    {
       if (!country)
         country = &c;
       else if (country != &c)
         return {};
   }
-  }
   return country ? country->GetName() : std::optional<std::string>{};
 }
 
@@ -145,10 +134,10 @@ std::vector<std::string> GetHonestAffiliations(T && t, IndexSharedPtr const & in
 {
   std::vector<std::string> affiliations;
   std::unordered_set<borders::CountryPolygons const *> countires;
-  ForEachPoint(t, [&](auto const & point) {
+  ForEachPoint(t, [&](auto const & point)
+  {
     std::vector<CountriesFilesIndexAffiliation::Value> values;
-    boost::geometry::index::query(*index, boost::geometry::index::covers(point),
+    boost::geometry::index::query(*index, boost::geometry::index::covers(point), std::back_inserter(values));
-                                  std::back_inserter(values));
     for (auto const & v : values)
     {
       if (v.second.size() == 1)
@@ -160,12 +149,10 @@ std::vector<std::string> GetHonestAffiliations(T && t, IndexSharedPtr const & in
       else
       {
         for (borders::CountryPolygons const & cp : v.second)
-        {
           if (cp.Contains(point) && countires.insert(&cp).second)
             affiliations.emplace_back(cp.GetName());
       }
     }
-    }
   });
 
   return affiliations;
@@ -182,8 +169,7 @@ std::vector<std::string> GetAffiliations(T && t, IndexSharedPtr const & index)
 CountriesFilesAffiliation::CountriesFilesAffiliation(std::string const & borderPath, bool haveBordersForWholeWorld)
   : m_countryPolygonsTree(borders::GetOrCreateCountryPolygonsTree(borderPath))
   , m_haveBordersForWholeWorld(haveBordersForWholeWorld)
-{
+{}
-}
 
 std::vector<std::string> CountriesFilesAffiliation::GetAffiliations(FeatureBuilder const & fb) const
 {
@@ -222,8 +208,7 @@ CountriesFilesIndexAffiliation::CountriesFilesIndexAffiliation(std::string const
     return;
   }
 
-  auto const net = generator::cells_merger::MakeNet(0.2 /* step */,
+  auto const net = generator::cells_merger::MakeNet(0.2 /* step */, mercator::Bounds::kMinX, mercator::Bounds::kMinY,
-                                                    mercator::Bounds::kMinX, mercator::Bounds::kMinY,
                                                     mercator::Bounds::kMaxX, mercator::Bounds::kMaxY);
   auto const index = BuildIndex(net);
   m_index = index;
@@ -240,8 +225,8 @@ std::vector<std::string> CountriesFilesIndexAffiliation::GetAffiliations(m2::Poi
   return affiliation::GetAffiliations(point, m_index);
 }
 
-std::shared_ptr<CountriesFilesIndexAffiliation::Tree>
+std::shared_ptr<CountriesFilesIndexAffiliation::Tree> CountriesFilesIndexAffiliation::BuildIndex(
-CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
+    std::vector<m2::RectD> const & net)
 {
   std::unordered_map<borders::CountryPolygons const *, std::vector<m2::RectD>> countriesRects;
   std::mutex countriesRectsMutex;
@@ -252,11 +237,11 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
     base::ComputationalThreadPool pool(numThreads);
     for (auto const & rect : net)
     {
-      pool.SubmitWork([&, rect]() {
+      pool.SubmitWork([&, rect]()
+      {
         std::vector<std::reference_wrapper<borders::CountryPolygons const>> countries;
-        m_countryPolygonsTree.ForEachCountryInRect(rect, [&](auto const & country) {
+        m_countryPolygonsTree.ForEachCountryInRect(rect,
-          countries.emplace_back(country);
+                                                   [&](auto const & country) { countries.emplace_back(country); });
-        });
         if (m_haveBordersForWholeWorld && countries.size() == 1)
         {
           borders::CountryPolygons const & country = countries.front();
@@ -269,7 +254,8 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
           std::vector<std::reference_wrapper<borders::CountryPolygons const>> interCountries;
           for (borders::CountryPolygons const & cp : countries)
           {
-            cp.ForAnyPolygon([&](auto const & polygon) {
+            cp.ForAnyPolygon([&](auto const & polygon)
+            {
               if (!boost::geometry::intersects(polygon.Data(), box))
                 return false;
               interCountries.emplace_back(cp);
@@ -297,7 +283,8 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
     base::ComputationalThreadPool pool(numThreads);
     for (auto & pair : countriesRects)
     {
-      pool.SubmitWork([&, countryPtr{pair.first}, rects{std::move(pair.second)}]() mutable {
+      pool.SubmitWork([&, countryPtr{pair.first}, rects{std::move(pair.second)}]() mutable
+      {
         generator::cells_merger::CellsMerger merger(std::move(rects));
         auto const merged = merger.Merge();
         for (auto const & rect : merged)
@@ -312,10 +299,7 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
   return std::make_shared<Tree>(treeCells);
 }
 
-SingleAffiliation::SingleAffiliation(std::string const & filename)
+SingleAffiliation::SingleAffiliation(std::string const & filename) : m_filename(filename) {}
-  : m_filename(filename)
-{
-}
 
 std::vector<std::string> SingleAffiliation::GetAffiliations(FeatureBuilder const &) const
 {
@@ -327,8 +311,7 @@ bool SingleAffiliation::HasCountryByName(std::string const & name) const
   return name == m_filename;
 }
 
-std::vector<std::string>
+std::vector<std::string> SingleAffiliation::GetAffiliations(m2::PointD const &) const
-SingleAffiliation::GetAffiliations(m2::PointD const &) const
 {
   return {m_filename};
 }

generator/affiliation.hpp

@@ -20,7 +20,6 @@ public:
   virtual std::vector<std::string> GetAffiliations(m2::PointD const & point) const = 0;
 
   virtual bool HasCountryByName(std::string const & name) const = 0;
-
 };
 
 class CountriesFilesAffiliation : public AffiliationInterface

generator/altitude_generator.cpp

@@ -35,10 +35,7 @@ public:
   explicit SrtmGetter(std::string const & srtmDir) : m_srtmManager(srtmDir) {}
 
   // AltitudeGetter overrides:
-  Altitude GetAltitude(m2::PointD const & p) override
+  Altitude GetAltitude(m2::PointD const & p) override { return m_srtmManager.GetAltitude(mercator::ToLatLon(p)); }
-  {
-    return m_srtmManager.GetAltitude(mercator::ToLatLon(p));
-  }
 
   void PrintStatsAndPurge() override
   {
@@ -56,18 +53,18 @@ public:
   struct FeatureAltitude
   {
     FeatureAltitude(uint32_t featureId, geometry::Altitudes && altitudes)
-      : m_featureId(featureId), m_altitudes(std::move(altitudes))
+      : m_featureId(featureId)
-    {
+      , m_altitudes(std::move(altitudes))
-    }
+    {}
 
     uint32_t m_featureId;
     feature::Altitudes m_altitudes;
   };
 
   explicit Processor(AltitudeGetter & altitudeGetter)
-    : m_minAltitude(geometry::kInvalidAltitude), m_altitudeGetter(altitudeGetter)
+    : m_minAltitude(geometry::kInvalidAltitude)
-  {
+    , m_altitudeGetter(altitudeGetter)
-  }
+  {}
 
   void operator()(FeatureType & f, uint32_t id)
   {
@@ -75,8 +72,7 @@ public:
     CHECK_EQUAL(id, m_altitudeAvailabilityBuilder.size(), ());
 
     bool hasAltitude = false;
-    SCOPE_GUARD(altitudeAvailabilityBuilding,
+    SCOPE_GUARD(altitudeAvailabilityBuilding, [&]() { m_altitudeAvailabilityBuilder.push_back(hasAltitude); });
-                [&]() { m_altitudeAvailabilityBuilder.push_back(hasAltitude); });
 
     if (!routing::IsRoad(feature::TypesHolder(f)))
       return;

generator/borders.cpp

@@ -39,8 +39,7 @@ template <class ToDo>
 void ForEachCountry(std::string const & baseDir, ToDo && toDo)
 {
   std::string const bordersDir = base::JoinPath(baseDir, BORDERS_DIR);
-  CHECK(Platform::IsFileExistsByFullPath(bordersDir),
+  CHECK(Platform::IsFileExistsByFullPath(bordersDir), ("Cannot read borders directory", bordersDir));
-        ("Cannot read borders directory", bordersDir));
 
   Platform::FilesList files;
   Platform::GetFilesByExt(bordersDir, BORDERS_EXTENSION, files);
@@ -58,9 +57,7 @@ void ForEachCountry(std::string const & baseDir, ToDo && toDo)
 class PackedBordersGenerator
 {
 public:
-  explicit PackedBordersGenerator(std::string const & baseDir) : m_writer(baseDir + PACKED_POLYGONS_FILE)
+  explicit PackedBordersGenerator(std::string const & baseDir) : m_writer(baseDir + PACKED_POLYGONS_FILE) {}
-  {
-  }
 
   void operator()(std::string name, PolygonsList && borders)
   {
@@ -138,9 +135,7 @@ bool ReadPolygon(std::istream & stream, Polygon & poly, std::string const & file
 bool CountryPolygons::Contains(m2::PointD const & point) const
 {
   return m_polygons.ForAnyInRect(m2::RectD(point, point), [&](auto const & rgn)
-  {
+  { return rgn.Contains(point, ContainsCompareFn(GetContainsEpsilon())); });
-    return rgn.Contains(point, ContainsCompareFn(GetContainsEpsilon()));
-  });
 }
 
 bool LoadBorders(std::string const & borderFile, PolygonsList & outBorders)
@@ -165,8 +160,7 @@ bool LoadBorders(std::string const & borderFile, PolygonsList & outBorders)
   return true;
 }
 
-bool GetBordersRect(std::string const & baseDir, std::string const & country,
+bool GetBordersRect(std::string const & baseDir, std::string const & country, m2::RectD & bordersRect)
-                    m2::RectD & bordersRect)
 {
   auto const bordersFile = base::JoinPath(baseDir, BORDERS_DIR, country + BORDERS_EXTENSION);
   if (!Platform::IsFileExistsByFullPath(bordersFile))

generator/borders.hpp

@@ -44,9 +44,9 @@ class CountryPolygons
 public:
   CountryPolygons() = default;
   explicit CountryPolygons(std::string && name, PolygonsTree && regions)
-      : m_name(std::move(name)), m_polygons(std::move(regions))
+    : m_name(std::move(name))
-  {
+    , m_polygons(std::move(regions))
-  }
+  {}
 
   std::string const & GetName() const { return m_name; }
   bool IsEmpty() const { return m_polygons.IsEmpty(); }
@@ -61,16 +61,12 @@ public:
     double m_eps, m_squareEps;
 
   public:
-    explicit ContainsCompareFn(double eps) : m_eps(eps), m_squareEps(eps*eps) {}
+    explicit ContainsCompareFn(double eps) : m_eps(eps), m_squareEps(eps * eps) {}
     bool EqualPoints(m2::PointD const & p1, m2::PointD const & p2) const
     {
-      return AlmostEqualAbs(p1.x, p2.x, m_eps) &&
+      return AlmostEqualAbs(p1.x, p2.x, m_eps) && AlmostEqualAbs(p1.y, p2.y, m_eps);
-             AlmostEqualAbs(p1.y, p2.y, m_eps);
-    }
-    bool EqualZeroSquarePrecision(double val) const
-    {
-      return AlmostEqualAbs(val, 0.0, m_squareEps);
     }
+    bool EqualZeroSquarePrecision(double val) const { return AlmostEqualAbs(val, 0.0, m_squareEps); }
   };
 
   static double GetContainsEpsilon() { return 1.0E-4; }
@@ -108,9 +104,7 @@ public:
 
     auto const & inserted = res.first->second;
     inserted.ForEachPolygon([&inserted, this](Polygon const & polygon)
-    {
+    { m_regionsTree.Add(inserted, polygon.GetRect()); });
-      m_regionsTree.Add(inserted, polygon.GetRect());
-    });
   }
 
   size_t GetSize() const { return m_countryPolygonsMap.size(); }
@@ -126,10 +120,7 @@ public:
     });
   }
 
-  bool HasRegionByName(std::string const & name) const
+  bool HasRegionByName(std::string const & name) const { return m_countryPolygonsMap.count(name) != 0; }
-  {
-    return m_countryPolygonsMap.count(name) != 0;
-  }
 
   CountryPolygons const & GetRegionByName(std::string const & name) const
   {
@@ -139,7 +130,7 @@ public:
   }
 
 private:
-  m4::Tree<std::reference_wrapper<const CountryPolygons>> m_regionsTree;
+  m4::Tree<std::reference_wrapper<CountryPolygons const>> m_regionsTree;
   std::unordered_map<std::string, CountryPolygons> m_countryPolygonsMap;
 };
 
@@ -148,8 +139,7 @@ using PolygonsList = std::vector<Polygon>;
 /// @return false if borderFile can't be opened
 bool LoadBorders(std::string const & borderFile, PolygonsList & outBorders);
 
-bool GetBordersRect(std::string const & baseDir, std::string const & country,
+bool GetBordersRect(std::string const & baseDir, std::string const & country, m2::RectD & bordersRect);
-                    m2::RectD & bordersRect);
 
 bool LoadCountriesList(std::string const & baseDir, CountryPolygonsCollection & countries);
 

generator/boundary_postcodes_enricher.cpp

@@ -28,8 +28,7 @@ BoundaryPostcodesEnricher::BoundaryPostcodesEnricher(std::string const & boundar
     CHECK(!postcode.empty() && !geometry.empty(), ());
 
     m_boundaryPostcodes.emplace_back(std::move(postcode), std::move(geometry));
-    m_boundariesTree.Add(m_boundaryPostcodes.size() - 1,
+    m_boundariesTree.Add(m_boundaryPostcodes.size() - 1, m_boundaryPostcodes.back().second.GetRect());
-                         m_boundaryPostcodes.back().second.GetRect());
   }
 }
 

generator/brands_loader.cpp

@@ -42,8 +42,7 @@ static void ParseFeatureToBrand(json_t * root, string const & field, GeoObjectId
   }
 }
 
-void ParseTranslations(json_t * root, std::set<string> const & keys,
+void ParseTranslations(json_t * root, std::set<string> const & keys, unordered_map<uint32_t, string> & idToKey)
-                       unordered_map<uint32_t, string> & idToKey)
 {
   string const empty;
   auto getKey = [&](string & translation) -> string const &

generator/camera_info_collector.cpp

@@ -18,8 +18,7 @@
 
 namespace generator
 {
-CamerasInfoCollector::CamerasInfoCollector(std::string const & dataFilePath,
+CamerasInfoCollector::CamerasInfoCollector(std::string const & dataFilePath, std::string const & camerasInfoPath,
-                                           std::string const & camerasInfoPath,
                                            std::string const & osmIdsToFeatureIdsPath)
 {
   routing::OsmIdToFeatureIds osmIdToFeatureIds;
@@ -90,8 +89,8 @@ void CamerasInfoCollector::Serialize(FileWriter & writer) const
     camera.Serialize(writer, prevFeatureId);
 }
 
-bool CamerasInfoCollector::ParseIntermediateInfo(
+bool CamerasInfoCollector::ParseIntermediateInfo(std::string const & camerasInfoPath,
-    std::string const & camerasInfoPath, routing::OsmIdToFeatureIds const & osmIdToFeatureIds)
+                                                 routing::OsmIdToFeatureIds const & osmIdToFeatureIds)
 {
   FileReader reader(camerasInfoPath);
   ReaderSource<FileReader> src(reader);
@@ -131,8 +130,8 @@ bool CamerasInfoCollector::ParseIntermediateInfo(
     if (relatedWaysNumber > std::numeric_limits<uint8_t>::max())
     {
       badCamera = true;
-      LOG(LERROR, ("Number of related to camera ways should be interval from 0 to 255.",
+      LOG(LERROR,
-                   "lat(", lat, "), lon(", lon, ")"));
+          ("Number of related to camera ways should be interval from 0 to 255.", "lat(", lat, "), lon(", lon, ")"));
     }
 
     std::vector<routing::SpeedCameraMwmPosition> ways;
@@ -159,8 +158,7 @@ bool CamerasInfoCollector::ParseIntermediateInfo(
   return true;
 }
 
-void CamerasInfoCollector::Camera::FindClosestSegment(FrozenDataSource const & dataSource,
+void CamerasInfoCollector::Camera::FindClosestSegment(FrozenDataSource const & dataSource, MwmSet::MwmId const & mwmId)
-                                                      MwmSet::MwmId const & mwmId)
 {
   if (!m_data.m_ways.empty() && FindClosestSegmentInInnerWays(dataSource, mwmId))
     return;
@@ -168,7 +166,6 @@ void CamerasInfoCollector::Camera::FindClosestSegment(FrozenDataSource const & d
   FindClosestSegmentWithGeometryIndex(dataSource);
 }
 
-
 bool CamerasInfoCollector::Camera::FindClosestSegmentInInnerWays(FrozenDataSource const & dataSource,
                                                                  MwmSet::MwmId const & mwmId)
 {
@@ -201,7 +198,8 @@ void CamerasInfoCollector::Camera::FindClosestSegmentWithGeometryIndex(FrozenDat
   double bestCoef = 0.0;
 
   // Look at each segment of roads and find the closest.
-  auto const updateClosestFeatureCallback = [&](FeatureType & ft) {
+  auto const updateClosestFeatureCallback = [&](FeatureType & ft)
+  {
     if (ft.GetGeomType() != feature::GeomType::Line)
       return;
 
@@ -243,8 +241,7 @@ void CamerasInfoCollector::Camera::FindClosestSegmentWithGeometryIndex(FrozenDat
     }
   };
 
-  dataSource.ForEachInRect(
+  dataSource.ForEachInRect(updateClosestFeatureCallback,
-    updateClosestFeatureCallback,
                            mercator::RectByCenterXYAndSizeInMeters(m_data.m_center, kSearchCameraRadiusMeters),
                            scales::GetUpperScale());
 
@@ -252,21 +249,24 @@ void CamerasInfoCollector::Camera::FindClosestSegmentWithGeometryIndex(FrozenDat
     m_data.m_ways.emplace_back(bestFeatureId, bestSegmentId, bestCoef);
 }
 
-std::optional<std::pair<double, uint32_t>> CamerasInfoCollector::Camera::FindMyself(
+std::optional<std::pair<double, uint32_t>> CamerasInfoCollector::Camera::FindMyself(uint32_t wayFeatureId,
-    uint32_t wayFeatureId, FrozenDataSource const & dataSource, MwmSet::MwmId const & mwmId) const
+                                                                                    FrozenDataSource const & dataSource,
+                                                                                    MwmSet::MwmId const & mwmId) const
 {
   double coef = 0.0;
   bool isRoad = true;
   uint32_t result = 0;
   bool cannotFindMyself = false;
 
-  auto const readFeature = [&](FeatureType & ft) {
+  auto const readFeature = [&](FeatureType & ft)
+  {
     bool found = false;
     isRoad = routing::IsRoad(feature::TypesHolder(ft));
     if (!isRoad)
       return;
 
-    auto const findPoint = [&result, &found, this](m2::PointD const & pt) {
+    auto const findPoint = [&result, &found, this](m2::PointD const & pt)
+    {
       if (found)
         return;
 
@@ -317,14 +317,12 @@ std::optional<std::pair<double, uint32_t>> CamerasInfoCollector::Camera::FindMys
   return {};
 }
 
-void CamerasInfoCollector::Camera::Serialize(FileWriter & writer,
+void CamerasInfoCollector::Camera::Serialize(FileWriter & writer, uint32_t & prevFeatureId) const
-                                             uint32_t & prevFeatureId) const
 {
   routing::SerializeSpeedCamera(writer, m_data, prevFeatureId);
 }
 
-void BuildCamerasInfo(std::string const & dataFilePath,
+void BuildCamerasInfo(std::string const & dataFilePath, std::string const & camerasInfoPath,
-                      std::string const & camerasInfoPath,
                       std::string const & osmIdsToFeatureIdsPath)
 {
   LOG(LINFO, ("Generating cameras info for", dataFilePath));

generator/camera_info_collector.hpp

@@ -32,8 +32,7 @@ private:
 
     Camera(m2::PointD const & center, uint8_t maxSpeed, std::vector<routing::SpeedCameraMwmPosition> && ways)
       : m_data(center, maxSpeed, std::move(ways))
-    {
+    {}
-    }
 
     void ParseDirection()
     {
@@ -56,8 +55,7 @@ private:
     // Returns empty object, if current feature - |wayId| is not the car road.
     // Otherwise returns id of segment from feature with id - |wayId|, which starts (or ends) at camera's
     // center and coefficient - where it placed at the segment: 0.0 (or 1.0).
-    std::optional<std::pair<double, uint32_t>> FindMyself(uint32_t wayFeatureId,
+    std::optional<std::pair<double, uint32_t>> FindMyself(uint32_t wayFeatureId, FrozenDataSource const & dataSource,
-                                                          FrozenDataSource const & dataSource,
                                                           MwmSet::MwmId const & mwmId) const;
 
     void Serialize(FileWriter & writer, uint32_t & prevFeatureId) const;
@@ -68,8 +66,7 @@ private:
   inline static double constexpr kMaxDistFromCameraToClosestSegmentMeters = 20.0;
   inline static double constexpr kSearchCameraRadiusMeters = 10.0;
 
-  bool ParseIntermediateInfo(std::string const & camerasInfoPath,
+  bool ParseIntermediateInfo(std::string const & camerasInfoPath, routing::OsmIdToFeatureIds const & osmIdToFeatureIds);
-                             routing::OsmIdToFeatureIds const & osmIdToFeatureIds);
 
   std::vector<Camera> m_cameras;
 };

generator/cells_merger.cpp

@@ -11,8 +11,7 @@ namespace
 double GetMinX(std::vector<m2::RectD> const & cells)
 {
   CHECK(!cells.empty(), ());
-  auto const minElementX =
+  auto const minElementX = std::min_element(std::cbegin(cells), std::cend(cells),
-      std::min_element(std::cbegin(cells), std::cend(cells),
                                             [](auto const & l, auto const & r) { return l.minX() < r.minX(); });
   return minElementX->minX();
 }
@@ -20,8 +19,7 @@ double GetMinX(std::vector<m2::RectD> const & cells)
 double GetMinY(std::vector<m2::RectD> const & cells)
 {
   CHECK(!cells.empty(), ());
-  auto const minElementY =
+  auto const minElementY = std::min_element(std::cbegin(cells), std::cend(cells),
-      std::min_element(std::cbegin(cells), std::cend(cells),
                                             [](auto const & l, auto const & r) { return l.minY() < r.minY(); });
   return minElementY->minY();
 }
@@ -70,8 +68,7 @@ void CellsMerger::CalcSum()
       if (!Has(x, y))
         continue;
       auto & cell = Get(x, y);
-      cell.SetBottomLeft(
+      cell.SetBottomLeft(std::min({TryGet(x - 1, y).GetBottomLeft(), TryGet(x, y - 1).GetBottomLeft(),
-          std::min({TryGet(x - 1, y).GetBottomLeft(), TryGet(x, y - 1).GetBottomLeft(),
                                    TryGet(x - 1, y - 1).GetBottomLeft()}) +
                          1);
     }
@@ -84,8 +81,7 @@ void CellsMerger::CalcSum()
       if (!Has(x, y))
         continue;
       auto & cell = Get(x, y);
-      cell.SetBottomRight(
+      cell.SetBottomRight(std::min({TryGet(x + 1, y).GetBottomRight(), TryGet(x, y - 1).GetBottomRight(),
-          std::min({TryGet(x + 1, y).GetBottomRight(), TryGet(x, y - 1).GetBottomRight(),
                                     TryGet(x + 1, y - 1).GetBottomRight()}) +
                           1);
     }
@@ -98,8 +94,8 @@ void CellsMerger::CalcSum()
       if (!Has(x, y))
         continue;
       auto & cell = Get(x, y);
-      cell.SetTopLeft(std::min({TryGet(x - 1, y).GetTopLeft(), TryGet(x, y + 1).GetTopLeft(),
+      cell.SetTopLeft(
-                                TryGet(x - 1, y + 1).GetTopLeft()}) +
+          std::min({TryGet(x - 1, y).GetTopLeft(), TryGet(x, y + 1).GetTopLeft(), TryGet(x - 1, y + 1).GetTopLeft()}) +
           1);
     }
   }
@@ -127,10 +123,12 @@ CellWrapper & CellsMerger::Get(m2::PointI const & xy)
   return it->second;
 }
 
-CellWrapper & CellsMerger::Get(int32_t x, int32_t y) { return Get({x, y}); }
+CellWrapper & CellsMerger::Get(int32_t x, int32_t y)
+{
+  return Get({x, y});
+}
 
-CellWrapper const & CellsMerger::TryGet(int32_t x, int32_t y,
+CellWrapper const & CellsMerger::TryGet(int32_t x, int32_t y, CellWrapper const & defaultValue) const
-                                        CellWrapper const & defaultValue) const
 {
   auto const it = m_matrix.find({x, y});
   return it == std::cend(m_matrix) ? defaultValue : it->second;
@@ -144,16 +142,12 @@ m2::PointI CellsMerger::FindBigSquare(m2::PointI const & xy, m2::PointI const &
   {
     auto const xMinMax = std::minmax(currXy.x, xy.x);
     for (int32_t x = xMinMax.first; x <= xMinMax.second; ++x)
-    {
       if (!Has({x, currXy.y}))
         return prevXy;
-    }
     auto const yMinMax = std::minmax(currXy.y, xy.y);
     for (int32_t y = yMinMax.first; y <= yMinMax.second; ++y)
-    {
       if (!Has({currXy.x, y}))
         return prevXy;
-    }
     prevXy = currXy;
     currXy += direction;
   }
@@ -163,16 +157,14 @@ std::optional<m2::PointI> CellsMerger::FindDirection(m2::PointI const & startXy)
 {
   std::array<std::pair<size_t, m2::PointI>, 4> directionsWithWeight;
   std::array<m2::PointI, 4> const directions{{{1, 1}, {-1, 1}, {1, -1}, {-1, -1}}};
-  base::Transform(directions, std::begin(directionsWithWeight),
+  base::Transform(directions, std::begin(directionsWithWeight), [&](auto const & direction)
-                  [&](auto const & direction) {
+  {
-                    return std::make_pair(
+    return std::make_pair(TryGet(startXy.x + direction.x, startXy.y).GetSum() +
-                        TryGet(startXy.x + direction.x, startXy.y).GetSum() +
                               TryGet(startXy.x, startXy.y + direction.y).GetSum() +
                               TryGet(startXy.x + direction.x, startXy.y + direction.y).GetSum(),
                           direction);
   });
-  auto const direction =
+  auto const direction = std::max_element(std::cbegin(directionsWithWeight), std::cend(directionsWithWeight))->second;
-      std::max_element(std::cbegin(directionsWithWeight), std::cend(directionsWithWeight))->second;
   return Has(startXy + direction) ? direction : std::optional<m2::PointI>{};
 }
 
@@ -181,15 +173,19 @@ void CellsMerger::Remove(m2::PointI const & minXy, m2::PointI const & maxXy)
   auto const xMinMax = std::minmax(minXy.x, maxXy.x);
   auto const yMinMax = std::minmax(minXy.y, maxXy.y);
   for (int32_t x = xMinMax.first; x <= xMinMax.second; ++x)
-  {
     for (int32_t y = yMinMax.first; y <= yMinMax.second; ++y)
       m_matrix.erase({x, y});
-  }
 }
 
-bool CellsMerger::Has(int32_t x, int32_t y) const { return m_matrix.count({x, y}) != 0; }
+bool CellsMerger::Has(int32_t x, int32_t y) const
+{
+  return m_matrix.count({x, y}) != 0;
+}
 
-bool CellsMerger::Has(const m2::PointI & xy) const { return Has(xy.x, xy.y); }
+bool CellsMerger::Has(m2::PointI const & xy) const
+{
+  return Has(xy.x, xy.y);
+}
 
 std::optional<m2::PointI> CellsMerger::FindMax() const
 {

generator/cells_merger.hpp

@@ -58,8 +58,7 @@ private:
   bool Has(m2::PointI const & xy) const;
   CellWrapper & Get(m2::PointI const & xy);
   CellWrapper & Get(int32_t x, int32_t y);
-  CellWrapper const & TryGet(int32_t x, int32_t y,
+  CellWrapper const & TryGet(int32_t x, int32_t y, CellWrapper const & defaultValue = CellWrapper::kEmpty) const;
-                             CellWrapper const & defaultValue = CellWrapper::kEmpty) const;
 
   void CalcSum();
   std::optional<m2::PointI> FindMax() const;

generator/centers_table_builder.cpp

@@ -35,10 +35,7 @@ bool BuildCentersTableFromDataFile(std::string const & filename, bool forceRebui
       FeaturesVector const features(rcont, header, table.get(), nullptr);
 
       builder.SetGeometryParams(header.GetBounds());
-      features.ForEach([&](FeatureType & ft, uint32_t featureId)
+      features.ForEach([&](FeatureType & ft, uint32_t featureId) { builder.Put(featureId, feature::GetCenter(ft)); });
-      {
-        builder.Put(featureId, feature::GetCenter(ft));
-      });
     }
 
     {

generator/check_model.cpp

@@ -2,9 +2,9 @@
 
 #include "defines.hpp"
 
-#include "indexer/features_vector.hpp"
 #include "indexer/classificator.hpp"
 #include "indexer/feature_visibility.hpp"
+#include "indexer/features_vector.hpp"
 
 #include "base/logging.hpp"
 

generator/cities_boundaries_builder.hpp

@@ -10,8 +10,7 @@
 namespace generator
 {
 // todo(@m) Make test ids a new source in base::GeoObjectId?
-using OsmIdToBoundariesTable =
+using OsmIdToBoundariesTable = base::ClusteringMap<base::GeoObjectId, indexer::CityBoundary>;
-    base::ClusteringMap<base::GeoObjectId, indexer::CityBoundary>;
 using TestIdToBoundariesTable = base::ClusteringMap<uint64_t, indexer::CityBoundary>;
 
 bool BuildCitiesBoundaries(std::string const & dataPath, OsmIdToBoundariesTable & table);

generator/cities_boundaries_checker.cpp

@@ -13,7 +13,8 @@ CitiesBoundariesChecker::CitiesBoundariesChecker(CitiesBoundaries const & cities
 bool CitiesBoundariesChecker::InCity(m2::PointD const & point) const
 {
   bool result = false;
-  m_tree.ForEachInRect(m2::RectD(point, point), [&](indexer::CityBoundary const & cityBoundary) {
+  m_tree.ForEachInRect(m2::RectD(point, point), [&](indexer::CityBoundary const & cityBoundary)
+  {
     if (result)
       return;
 

generator/cities_ids_builder.cpp

@@ -11,8 +11,8 @@
 #include "search/localities_source.hpp"
 #include "search/mwm_context.hpp"
 
-#include "coding/files_container.hpp"
 #include "coding/file_writer.hpp"
+#include "coding/files_container.hpp"
 
 #include "base/cancellable.hpp"
 #include "base/checked_cast.hpp"
@@ -44,7 +44,8 @@ void WriteCitiesIdsSectionToFile(std::string const & dataPath,
 {
   indexer::FeatureIdToGeoObjectIdBimapMem map;
   auto const localities = generator::GetLocalities(dataPath);
-  localities.ForEach([&](uint64_t fid64) {
+  localities.ForEach([&](uint64_t fid64)
+  {
     auto const fid = base::checked_cast<uint32_t>(fid64);
     auto const it = mapping.find(fid);
     if (it == mapping.end())
@@ -58,8 +59,7 @@ void WriteCitiesIdsSectionToFile(std::string const & dataPath,
       auto const hasOldOsmId = map.GetValue(fid, oldOsmId);
       auto const hasOldFid = map.GetKey(osmId, oldFid);
 
-      LOG(LWARNING,
+      LOG(LWARNING, ("Could not add the pair (", fid, ",", osmId,
-          ("Could not add the pair (", fid, ",", osmId,
                      ") to the cities ids section; old fid:", (hasOldFid ? DebugPrint(oldFid) : "none"),
                      "old osmId:", (hasOldOsmId ? DebugPrint(oldOsmId) : "none")));
     }
@@ -73,8 +73,7 @@ void WriteCitiesIdsSectionToFile(std::string const & dataPath,
   indexer::FeatureIdToGeoObjectIdSerDes::Serialize(*sink, map);
   auto const pos1 = sink->Pos();
 
-  LOG(LINFO,
+  LOG(LINFO, ("Serialized cities ids. Number of entries:", map.Size(), "Size in bytes:", pos1 - pos0));
-      ("Serialized cities ids. Number of entries:", map.Size(), "Size in bytes:", pos1 - pos0));
 }
 }  // namespace
 

generator/city_roads_generator.cpp

@@ -23,8 +23,7 @@ namespace routing_builder
 using generator::CitiesBoundariesChecker;
 using std::string, std::vector;
 
-void LoadCitiesBoundariesGeometry(string const & boundariesPath,
+void LoadCitiesBoundariesGeometry(string const & boundariesPath, CitiesBoundariesChecker::CitiesBoundaries & result)
-                                  CitiesBoundariesChecker::CitiesBoundaries & result)
 {
   if (!Platform::IsFileExistsByFullPath(boundariesPath))
   {
@@ -44,8 +43,8 @@ void LoadCitiesBoundariesGeometry(string const & boundariesPath,
     {
       ++points;
       double const radiusM = ftypes::GetRadiusByPopulationForRouting(loc.GetPopulation(), loc.GetPlace());
-      result.emplace_back(ms::CreateCircleGeometryOnEarth(
+      result.emplace_back(
-                            mercator::ToLatLon(loc.m_center), radiusM, 30.0 /* angleStepDegree */));
+          ms::CreateCircleGeometryOnEarth(mercator::ToLatLon(loc.m_center), radiusM, 30.0 /* angleStepDegree */));
     }
     else
     {
@@ -63,7 +62,6 @@ void LoadCitiesBoundariesGeometry(string const & boundariesPath,
 /// according to |table|.
 vector<uint32_t> CalcRoadFeatureIds(string const & dataPath, string const & boundariesPath)
 {
-
   CitiesBoundariesChecker::CitiesBoundaries citiesBoundaries;
   LoadCitiesBoundariesGeometry(boundariesPath, citiesBoundaries);
   CitiesBoundariesChecker const checker(citiesBoundaries);
@@ -80,10 +78,8 @@ vector<uint32_t> CalcRoadFeatureIds(string const & dataPath, string const & boun
     size_t inCityPointsCounter = 0;
     size_t const count = ft.GetPointsCount();
     for (size_t i = 0; i < count; ++i)
-    {
       if (checker.InCity(ft.GetPoint(i)))
         ++inCityPointsCounter;
-    }
 
     // Our approximation of boundary overestimates it, because of different
     // bounding boxes (in order to increase performance). So we don't want

generator/cluster_finder.hpp

@@ -14,7 +14,8 @@ namespace generator
 {
 // The class ClustersFinder finds clusters of objects for which IsSameFunc returns true.
 // RadiusFunc should return the same radius for all objects in one cluster.
-template <class T> class ClustersFinder
+template <class T>
+class ClustersFinder
 {
 public:
   using PtrT = T const *;
@@ -22,7 +23,9 @@ public:
   using IsSameFunc = std::function<bool(T const &, T const &)>;
 
   ClustersFinder(std::vector<T> const & container, RadiusFunc radiusFunc, IsSameFunc isSameFunc)
-    : m_container(container), m_radiusFunc(std::move(radiusFunc)), m_isSameFunc(std::move(isSameFunc))
+    : m_container(container)
+    , m_radiusFunc(std::move(radiusFunc))
+    , m_isSameFunc(std::move(isSameFunc))
   {
     for (auto const & e : m_container)
       m_tree.Add(&e);
@@ -78,10 +81,7 @@ private:
   {
     m2::RectD bbox;
     auto const dist = m_radiusFunc(*p);
-    GetLimitRect(*p).ForEachCorner([&](auto const & p)
+    GetLimitRect(*p).ForEachCorner([&](auto const & p) { bbox.Add(mercator::RectByCenterXYAndSizeInMeters(p, dist)); });
-    {
-      bbox.Add(mercator::RectByCenterXYAndSizeInMeters(p, dist));
-    });
     return bbox;
   }
 
@@ -93,7 +93,8 @@ private:
 
 /// @return Vector of equal place clusters, like pointers from input \a container.
 template <class T, class RadiusFnT, class IsSameFnT>
-std::vector<std::vector<T const *>> GetClusters(std::vector<T> const & container, RadiusFnT && radiusFunc, IsSameFnT && isSameFunc)
+std::vector<std::vector<T const *>> GetClusters(std::vector<T> const & container, RadiusFnT && radiusFunc,
+                                                IsSameFnT && isSameFunc)
 {
   return ClustersFinder<T>(container, std::forward<RadiusFnT>(radiusFunc), std::forward<IsSameFnT>(isSameFunc)).Find();
 }

generator/coastlines_generator.cpp

@@ -15,7 +15,6 @@
 #include <functional>
 #include <thread>
 
-
 namespace coastlines_generator
 {
 using RegionT = m2::RegionI;
@@ -53,9 +52,12 @@ class DoAddToTree : public FeatureEmitterIFace
 
 public:
   explicit DoAddToTree(CoastlineFeaturesGenerator & rMain)
-    : m_rMain(rMain), m_notMergedCoastsCount(0), m_totalNotMergedCoastsPoints(0) {}
+    : m_rMain(rMain)
+    , m_notMergedCoastsCount(0)
+    , m_totalNotMergedCoastsPoints(0)
+  {}
 
-  virtual void operator() (feature::FeatureBuilder const & fb)
+  virtual void operator()(feature::FeatureBuilder const & fb)
   {
     if (fb.IsGeometryClosed())
       m_rMain.AddRegionToTree(fb);
@@ -64,30 +66,20 @@ public:
       base::GeoObjectId const firstWay = fb.GetFirstOsmId();
       base::GeoObjectId const lastWay = fb.GetLastOsmId();
       if (firstWay == lastWay)
-        LOG(LINFO, ("Not merged coastline, way", firstWay.GetSerialId(), "(", fb.GetPointsCount(),
+        LOG(LINFO, ("Not merged coastline, way", firstWay.GetSerialId(), "(", fb.GetPointsCount(), "points)"));
-                    "points)"));
       else
-        LOG(LINFO, ("Not merged coastline, ways", firstWay.GetSerialId(), "to",
+        LOG(LINFO, ("Not merged coastline, ways", firstWay.GetSerialId(), "to", lastWay.GetSerialId(), "(",
-                    lastWay.GetSerialId(), "(", fb.GetPointsCount(), "points)"));
+                    fb.GetPointsCount(), "points)"));
       ++m_notMergedCoastsCount;
       m_totalNotMergedCoastsPoints += fb.GetPointsCount();
     }
   }
 
-  bool HasNotMergedCoasts() const
+  bool HasNotMergedCoasts() const { return m_notMergedCoastsCount != 0; }
-  {
-    return m_notMergedCoastsCount != 0;
-  }
 
-  size_t GetNotMergedCoastsCount() const
+  size_t GetNotMergedCoastsCount() const { return m_notMergedCoastsCount; }
-  {
-    return m_notMergedCoastsCount;
-  }
 
-  size_t GetNotMergedCoastsPoints() const
+  size_t GetNotMergedCoastsPoints() const { return m_totalNotMergedCoastsPoints; }
-  {
-    return m_totalNotMergedCoastsPoints;
-  }
 };
 
 class DoDifference
@@ -129,8 +121,8 @@ public:
 
       m_res[i].ForEachPoint([&points](PointT const & p)
       {
-        points.push_back(PointUToPointD(
+        points.push_back(
-            m2::PointU(static_cast<uint32_t>(p.x), static_cast<uint32_t>(p.y)), kPointCoordBits));
+            PointUToPointD(m2::PointU(static_cast<uint32_t>(p.x), static_cast<uint32_t>(p.y)), kPointCoordBits));
       });
 
       fb.AddPolygon(std::move(points));
@@ -139,8 +131,7 @@ public:
 };
 }  // namespace coastlines_generator
 
-CoastlineFeaturesGenerator::CoastlineFeaturesGenerator()
+CoastlineFeaturesGenerator::CoastlineFeaturesGenerator() : m_merger(kPointCoordBits) {}
-  : m_merger(kPointCoordBits) {}
 
 void CoastlineFeaturesGenerator::AddRegionToTree(feature::FeatureBuilder const & fb)
 {
@@ -206,13 +197,10 @@ protected:
   Context & m_ctx;
   TIndex const & m_index;
 
-  RegionInCellSplitter(Context & ctx,TIndex const & index)
+  RegionInCellSplitter(Context & ctx, TIndex const & index) : m_ctx(ctx), m_index(index) {}
-  : m_ctx(ctx), m_index(index)
-  {}
 
 public:
-  static bool Process(size_t numThreads, size_t baseScale, TIndex const & index,
+  static bool Process(size_t numThreads, size_t baseScale, TIndex const & index, TProcessResultFunc funcResult)
-                      TProcessResultFunc funcResult)
   {
     /// @todo Replace with base::ComputationalThreadPool
 
@@ -246,8 +234,8 @@ public:
 
     using namespace coastlines_generator;
     // create rect region
-    PointT arr[] = {D2I(m2::PointD(minX, minY)), D2I(m2::PointD(minX, maxY)),
+    PointT arr[] = {D2I(m2::PointD(minX, minY)), D2I(m2::PointD(minX, maxY)), D2I(m2::PointD(maxX, maxY)),
-                    D2I(m2::PointD(maxX, maxY)), D2I(m2::PointD(maxX, minY))};
+                    D2I(m2::PointD(maxX, minY))};
     RegionT rectR(arr, arr + ARRAY_SIZE(arr));
 
     // Do 'and' with all regions and accumulate the result, including bound region.
@@ -269,7 +257,7 @@ public:
     while (true)
     {
       std::unique_lock lock(m_ctx.mutexTasks);
-      m_ctx.listCondVar.wait(lock, [&]{return (!m_ctx.listTasks.empty() || m_ctx.inWork == 0);});
+      m_ctx.listCondVar.wait(lock, [&] { return (!m_ctx.listTasks.empty() || m_ctx.inWork == 0); });
       if (m_ctx.listTasks.empty())
         break;
 
@@ -283,10 +271,8 @@ public:
       lock.lock();
       // return to queue not ready cells
       if (!done)
-      {
         for (int8_t i = 0; i < TCell::MAX_CHILDREN; ++i)
           m_ctx.listTasks.push_back(currentCell.Child(i));
-      }
       --m_ctx.inWork;
       m_ctx.listCondVar.notify_all();
     }
@@ -300,7 +286,8 @@ std::vector<feature::FeatureBuilder> CoastlineFeaturesGenerator::GetFeatures(siz
   std::vector<feature::FeatureBuilder> features;
   std::mutex featuresMutex;
 
-  RegionInCellSplitter::Process(maxThreads, RegionInCellSplitter::kStartLevel, m_tree,
+  RegionInCellSplitter::Process(
+      maxThreads, RegionInCellSplitter::kStartLevel, m_tree,
       [&](RegionInCellSplitter::TCell const & cell, coastlines_generator::DoDifference & cellData)
   {
     feature::FeatureBuilder fb;