diff --git a/android/jni/com/mapswithme/maps/Framework.cpp b/android/jni/com/mapswithme/maps/Framework.cpp
index 68ee7e9145..e6854835c7 100644
--- a/android/jni/com/mapswithme/maps/Framework.cpp
+++ b/android/jni/com/mapswithme/maps/Framework.cpp
@@ -373,12 +373,16 @@ namespace android
   void Framework::ShowCountry(m2::RectD const & r)
   {
     m_doLoadState = false;
+
+    m_work.SkipLocationCentering();
     m_work.ShowRect(r);
   }
 
   void Framework::ShowSearchResult(search::Result const & r)
   {
     m_doLoadState = false;
+
+    m_work.SkipLocationCentering();
     m_work.ShowSearchResult(r);
   }
 
diff --git a/android/jni/com/mapswithme/maps/MWMActivity.cpp b/android/jni/com/mapswithme/maps/MWMActivity.cpp
index 383d80fb49..304870cae4 100644
--- a/android/jni/com/mapswithme/maps/MWMActivity.cpp
+++ b/android/jni/com/mapswithme/maps/MWMActivity.cpp
@@ -54,32 +54,19 @@ extern "C"
     return ret;
   }
 
-  JNIEXPORT jboolean JNICALL
-  Java_com_mapswithme_maps_MWMActivity_hasMeasurementSystem(JNIEnv * env, jobject thiz)
-  {
-    Settings::Units u;
-    return Settings::Get("Units", u);
-  }
-
   JNIEXPORT void JNICALL
-  Java_com_mapswithme_maps_MWMActivity_setMeasurementSystem(JNIEnv * env, jobject thiz, jint systemIdx)
+  Java_com_mapswithme_maps_MWMActivity_nativeSetMS(JNIEnv * env, jobject thiz, jint systemIdx)
   {
-    Settings::Units u = (Settings::Units)systemIdx;
+    Settings::Units const u = static_cast<Settings::Units>(systemIdx);
     Settings::Set("Units", u);
-  }
-
-  JNIEXPORT void JNICALL
-  Java_com_mapswithme_maps_MWMActivity_setupMeasurementSystem(JNIEnv * env, jobject thiz)
-  {
     g_framework->SetupMeasurementSystem();
   }
 
   JNIEXPORT jint JNICALL
-  Java_com_mapswithme_maps_MWMActivity_getMeasurementSystem(JNIEnv * env, jobject thiz)
+  Java_com_mapswithme_maps_MWMActivity_nativeGetMS(JNIEnv * env, jobject thiz)
   {
     Settings::Units u = Settings::Metric;
-    Settings::Get("Units", u);
-    return u;
+    return (Settings::Get("Units", u) ? u : -1);
   }
 
   void CallOnDownloadCountryClicked(shared_ptr<jobject> const & obj,
diff --git a/android/src/com/mapswithme/maps/MWMActivity.java b/android/src/com/mapswithme/maps/MWMActivity.java
index 04443af1a7..b3cf4dd233 100644
--- a/android/src/com/mapswithme/maps/MWMActivity.java
+++ b/android/src/com/mapswithme/maps/MWMActivity.java
@@ -29,18 +29,21 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
 
   private static String TAG = "MWMActivity";
 
+  private MWMApplication mApplication = null;
   private BroadcastReceiver m_externalStorageReceiver = null;
   private AlertDialog m_storageDisconnectedDialog = null;
   private boolean m_shouldStartLocationService = false;
 
-  private static Context m_context = null;
-  public static Context getCurrentContext() { return m_context; }
+  private LocationService getLocationService()
+  {
+    return mApplication.getLocationService();
+  }
 
   public void checkShouldStartLocationService()
   {
     if (m_shouldStartLocationService)
     {
-      mApplication.getLocationService().startUpdate(this);
+      getLocationService().startUpdate(this);
       m_shouldStartLocationService = false;
     }
   }
@@ -79,6 +82,8 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
     });
   }
 
+  private Activity getActivity() { return this; }
+
   @Override
   public void ReportUnsupported()
   {
@@ -87,111 +92,95 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
       @Override
       public void run()
       {
-        AlertDialog alert = new AlertDialog.Builder(getCurrentContext()).create();
-
-        alert.setMessage(getString(R.string.unsupported_phone));
-
-        alert.setCancelable(false);
-
-        alert.setButton(AlertDialog.BUTTON_POSITIVE, getString(R.string.close),
-                        new DialogInterface.OnClickListener()
+        new AlertDialog.Builder(getActivity())
+        .setMessage(getString(R.string.unsupported_phone))
+        .setCancelable(false)
+        .setPositiveButton(getString(R.string.close), new DialogInterface.OnClickListener()
         {
           @Override
           public void onClick(DialogInterface dlg, int which)
           {
-            Activity a = (Activity)getCurrentContext();
-            a.moveTaskToBack(true);
+            getActivity().moveTaskToBack(true);
             dlg.dismiss();
           }
-        });
-
-        alert.show();
+        })
+        .create()
+        .show();
       }
     });
+  }
 
+  private void setMeasurementSystem(int u)
+  {
+    nativeSetMS(u);
+    checkProVersionAvailable();
   }
 
   private void checkMeasurementSystem()
   {
-    int u;
-    if (!hasMeasurementSystem())
+    final int u = nativeGetMS();
+    if (u == UNITS_UNDEFINED)
     {
       // Checking system-default measurement system
       if (UnitLocale.getCurrent() == UnitLocale.Metric)
       {
-        u = UNITS_METRIC;
-        setupMeasurementSystem();
-        checkProVersionAvailable();
-      } else
+        setMeasurementSystem(UNITS_METRIC);
+      }
+      else
       {
-        u = UNITS_FOOT;
-
         // showing "select measurement system" dialog.
-        AlertDialog alert = new AlertDialog.Builder(this).create();
-        alert.setCancelable(false);
-
-        alert.setMessage(getString(R.string.which_measurement_system));
-
-        alert.setButton(AlertDialog.BUTTON_NEGATIVE, getString(R.string.miles),
-                        new DialogInterface.OnClickListener()
+        new AlertDialog.Builder(this)
+        .setCancelable(false)
+        .setMessage(getString(R.string.which_measurement_system))
+        .setNegativeButton(getString(R.string.miles), new DialogInterface.OnClickListener()
         {
           @Override
           public void onClick(DialogInterface dialog, int which)
           {
-            setMeasurementSystem(UNITS_FOOT);
-            setupMeasurementSystem();
             dialog.dismiss();
-            checkProVersionAvailable();
+            setMeasurementSystem(UNITS_FOOT);
           }
-        });
-
-        alert.setButton(AlertDialog.BUTTON_POSITIVE, getString(R.string.kilometres),
-                        new DialogInterface.OnClickListener()
+        })
+        .setPositiveButton(getString(R.string.kilometres), new DialogInterface.OnClickListener()
         {
           @Override
           public void onClick(DialogInterface dlg, int which)
           {
-            setMeasurementSystem(UNITS_METRIC);
-            setupMeasurementSystem();
             dlg.dismiss();
-            checkProVersionAvailable();
+            setMeasurementSystem(UNITS_METRIC);
           }
-        });
-
-        alert.show();
+        })
+        .create()
+        .show();
       }
-
-      setMeasurementSystem(u);
-    } else
+    }
+    else
     {
-      setupMeasurementSystem();
-      checkProVersionAvailable();
+      setMeasurementSystem(u);
     }
   }
 
-  private native boolean hasMeasurementSystem();
-
+  /// This constants should be equal with Settings::Units in settings.hpp
+  private final int UNITS_UNDEFINED = -1;
   private final int UNITS_METRIC = 0;
   private final int UNITS_YARD = 1;
   private final int UNITS_FOOT = 2;
 
-  private native int getMeasurementSystem();
-
-  private native void setMeasurementSystem(int u);
-
-  private native void setupMeasurementSystem();
+  private native int nativeGetMS();
+  private native void nativeSetMS(int u);
 
   private static final String PREFERENCES_MYPOSITION = "isMyPositionEnabled";
 
+
   public void onMyPositionClicked(View v)
   {
     v.setBackgroundResource(R.drawable.myposition_button_normal);
 
     final boolean isLocationActive = v.isSelected();
     if (isLocationActive)
-      mApplication.getLocationService().stopUpdate(this);
+      getLocationService().stopUpdate(this);
     else
-      mApplication.getLocationService().startUpdate(this);
+      getLocationService().startUpdate(this);
     v.setSelected(!isLocationActive);
 
     // Store active state of My Position
@@ -226,14 +215,10 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
 
   void showProVersionBanner(String message)
   {
-    AlertDialog alert = new AlertDialog.Builder(getCurrentContext()).create();
-
-    alert.setMessage(message);
-
-    alert.setCancelable(false);
-
-    alert.setButton(AlertDialog.BUTTON_POSITIVE, getString(R.string.buy_now),
-                    new DialogInterface.OnClickListener()
+    new AlertDialog.Builder(getActivity())
+    .setMessage(message)
+    .setCancelable(false)
+    .setPositiveButton(getString(R.string.buy_now), new DialogInterface.OnClickListener()
     {
       @Override
       public void onClick(DialogInterface dlg, int which)
@@ -242,20 +227,17 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
         dlg.dismiss();
         startActivity(i);
       }
-    });
-
-    alert.setButton(AlertDialog.BUTTON_NEGATIVE, getString(R.string.later),
-                    new DialogInterface.OnClickListener()
+    })
+    .setNegativeButton(getString(R.string.later), new DialogInterface.OnClickListener()
     {
       @Override
       public void onClick(DialogInterface dlg, int which)
       {
         dlg.dismiss();
       }
-    });
-
-    alert.show();
-
+    })
+    .create()
+    .show();
   }
 
   public void onSearchClicked(View v)
@@ -271,8 +253,6 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
     startActivity(new Intent(this, DownloadUI.class));
   }
 
-  private MWMApplication mApplication;
-
   @Override
   public void onCreate(Bundle savedInstanceState)
   {
@@ -285,8 +265,6 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
 
     super.onCreate(savedInstanceState);
 
-    m_context = this;
-
     mApplication = (MWMApplication)getApplication();
 
     // Get screen density
@@ -376,10 +354,7 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
   @Override
   protected void onPause()
   {
-    // stop update only if it's started in OnRenderingInitialized
-    if (!m_shouldStartLocationService)
-      if (findViewById(R.id.map_button_myposition).isSelected())
-        mApplication.getLocationService().stopUpdate(this);
+    getLocationService().stopUpdate(this);
 
     stopWatchingExternalStorage();
 
@@ -394,7 +369,8 @@ public class MWMActivity extends NvEventQueueActivity implements LocationService
     {
       // Change button appearance to "looking for position"
       button.setBackgroundResource(R.drawable.myposition_button_normal);
-      /// and remember to start locationService updates in OnRenderingInitialized
+
+      // and remember to start locationService updates in OnRenderingInitialized
       m_shouldStartLocationService = true;
     }
 
diff --git a/geometry/screenbase.cpp b/geometry/screenbase.cpp
index a5ae3bad74..7966cafee3 100644
--- a/geometry/screenbase.cpp
+++ b/geometry/screenbase.cpp
@@ -146,6 +146,11 @@ m2::RectD const & ScreenBase::ClipRect() const
   return m_ClipRect;
 }
 
+double ScreenBase::GetMinPixelRectSize() const
+{
+  return min(m_PixelRect.SizeX(), m_PixelRect.SizeY());
+}
+
 double ScreenBase::GetScale() const
 {
   return m_Scale;
diff --git a/geometry/screenbase.hpp b/geometry/screenbase.hpp
index 38f786cb39..ca380f320d 100644
--- a/geometry/screenbase.hpp
+++ b/geometry/screenbase.hpp
@@ -102,6 +102,8 @@ public:
   m2::AnyRectD const & GlobalRect() const;
   m2::RectD const & ClipRect() const;
 
+  double GetMinPixelRectSize() const;
+
   /// Compute arbitrary pixel transformation, that translates the (oldPt1, oldPt2) -> (newPt1, newPt2)
   static math::Matrix<double, 3, 3> const CalcTransform(m2::PointD const & oldPt1, m2::PointD const & oldPt2,
                                                         m2::PointD const & newPt1, m2::PointD const & newPt2);
diff --git a/map/framework.cpp b/map/framework.cpp
index fe7d759eea..7c5f4970db 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -44,15 +44,24 @@ void Framework::RemoveMap(string const & datFile)
   m_model.RemoveMap(datFile);
 }
 
+void Framework::SkipLocationCentering()
+{
+  m_centeringMode = ESkipLocationCentering;
+}
+
 void Framework::OnLocationStatusChanged(location::TLocationStatus newStatus)
 {
   switch (newStatus)
   {
   case location::EStarted:
   case location::EFirstEvent:
-    // reset centering mode
-    m_centeringMode = ECenterAndScale;
+    if (m_centeringMode != ESkipLocationCentering)
+    {
+      // set centering mode for the first location
+      m_centeringMode = ECenterAndScale;
+    }
     break;
+
   default:
     m_centeringMode = EDoNothing;
     m_locationState.TurnOff();
@@ -68,18 +77,40 @@ void Framework::OnGpsUpdate(location::GpsInfo const & info)
 
   m_locationState.UpdateGps(rect);
 
-  if (m_centeringMode == ECenterAndScale)
+  switch (m_centeringMode)
   {
+  case ECenterAndScale:
+  {
+    int const rectScale = scales::GetScaleLevel(rect);
+    int setScale = -1;
+
+    // correct rect scale if country isn't downloaded
     int const upperScale = scales::GetUpperWorldScale();
-    if (scales::GetScaleLevel(rect) > upperScale && IsEmptyModel(center))
-      rect = scales::GetRectForLevel(upperScale, center, 1.0);
+    if (rectScale > upperScale && IsEmptyModel(center))
+      setScale = upperScale;
+
+    // correct rect scale for best user experience
+    int const bestScale = scales::GetUpperScale() - 1;
+    if (rectScale > bestScale)
+      setScale = bestScale;
+
+    if (setScale != -1)
+      rect = scales::GetRectForLevel(setScale, center, 1.0);
 
     ShowRectFixed(rect);
 
     m_centeringMode = ECenterOnly;
+    break;
   }
-  else if (m_centeringMode == ECenterOnly)
+
+  case ECenterOnly:
     SetViewportCenter(center);
+    break;
+
+  case ESkipLocationCentering:
+    m_centeringMode = EDoNothing;
+    break;
+  }
 }
 
 void Framework::OnCompassUpdate(location::CompassInfo const & info)
@@ -651,7 +682,12 @@ void Framework::ShowAll()
 }
 
 /// @name Drag implementation.
-///@{
+//@{
+m2::PointD Framework::GetPixelCenter() const
+{
+  return m_navigator.Screen().PixelRect().Center();
+}
+
 void Framework::StartDrag(DragEvent const & e)
 {
   m2::PointD const pt = m_navigator.ShiftPoint(e.Pos());
@@ -663,15 +699,12 @@ void Framework::StartDrag(DragEvent const & e)
 
   if (m_renderPolicy)
     m_renderPolicy->StartDrag();
-//  LOG(LINFO, ("StartDrag", e.Pos()));
 }
 
 void Framework::DoDrag(DragEvent const & e)
 {
   m2::PointD const pt = m_navigator.ShiftPoint(e.Pos());
 
-  m_centeringMode = EDoNothing;
-
 #ifdef DRAW_TOUCH_POINTS
   m_informationDisplay.setDebugPoint(0, pt);
 #endif
@@ -679,7 +712,6 @@ void Framework::DoDrag(DragEvent const & e)
   m_navigator.DoDrag(pt, ElapsedSeconds());
   if (m_renderPolicy)
     m_renderPolicy->DoDrag();
-//  LOG(LINFO, ("DoDrag", e.Pos()));
 }
 
 void Framework::StopDrag(DragEvent const & e)
@@ -689,13 +721,19 @@ void Framework::StopDrag(DragEvent const & e)
   m_navigator.StopDrag(pt, ElapsedSeconds(), true);
 
 #ifdef DRAW_TOUCH_POINTS
-  m_informationDisplay.setDebugPoint(0, m2::PointD(0, 0));
+  m_informationDisplay.setDebugPoint(0, pt);
 #endif
 
+  if (m_centeringMode != EDoNothing)
+  {
+    // reset GPS centering mode if we have dragged far from current location
+    ScreenBase const & s = m_navigator.Screen();
+    if (GetPixelCenter().Length(s.GtoP(m_locationState.Position())) >= s.GetMinPixelRectSize() / 2.0)
+      m_centeringMode = EDoNothing;
+  }
+
   if (m_renderPolicy)
     m_renderPolicy->StopDrag();
-
-//  LOG(LINFO, ("StopDrag", e.Pos()));
 }
 
 void Framework::StartRotate(RotateEvent const & e)
@@ -737,8 +775,8 @@ void Framework::Move(double azDir, double factor)
 //@{
 void Framework::ScaleToPoint(ScaleToPointEvent const & e)
 {
-  m2::PointD const pt = (m_centeringMode == EDoNothing)
-      ? m_navigator.ShiftPoint(e.Pt()) : m_navigator.Screen().PixelRect().Center();
+  m2::PointD const pt = (m_centeringMode == EDoNothing) ?
+        m_navigator.ShiftPoint(e.Pt()) : GetPixelCenter();
 
   m_navigator.ScaleToPoint(pt, e.ScaleFactor(), ElapsedSeconds());
 
@@ -757,15 +795,15 @@ void Framework::Scale(double scale)
   Invalidate();
 }
 
-void Framework::StartScale(ScaleEvent const & e)
+void Framework::CalcScalePoints(ScaleEvent const & e, m2::PointD & pt1, m2::PointD & pt2) const
 {
-  m2::PointD pt1 = m_navigator.ShiftPoint(e.Pt1());
-  m2::PointD pt2 = m_navigator.ShiftPoint(e.Pt2());
+  pt1 = m_navigator.ShiftPoint(e.Pt1());
+  pt2 = m_navigator.ShiftPoint(e.Pt2());
 
   if ((m_locationState & location::State::EGps) && (m_centeringMode == ECenterOnly))
   {
-    m2::PointD ptC = (pt1 + pt2) / 2;
-    m2::PointD ptDiff = m_navigator.Screen().PixelRect().Center() - ptC;
+    m2::PointD const ptC = (pt1 + pt2) / 2;
+    m2::PointD const ptDiff = GetPixelCenter() - ptC;
     pt1 += ptDiff;
     pt2 += ptDiff;
   }
@@ -774,61 +812,38 @@ void Framework::StartScale(ScaleEvent const & e)
   m_informationDisplay.setDebugPoint(0, pt1);
   m_informationDisplay.setDebugPoint(1, pt2);
 #endif
+}
+
+void Framework::StartScale(ScaleEvent const & e)
+{
+  m2::PointD pt1, pt2;
+  CalcScalePoints(e, pt1, pt2);
 
   m_navigator.StartScale(pt1, pt2, ElapsedSeconds());
   if (m_renderPolicy)
     m_renderPolicy->StartScale();
-
-//  LOG(LINFO, ("StartScale", e.Pt1(), e.Pt2()));
 }
 
 void Framework::DoScale(ScaleEvent const & e)
 {
-  m2::PointD pt1 = m_navigator.ShiftPoint(e.Pt1());
-  m2::PointD pt2 = m_navigator.ShiftPoint(e.Pt2());
-
-  if ((m_locationState & location::State::EGps) && (m_centeringMode == ECenterOnly))
-  {
-    m2::PointD ptC = (pt1 + pt2) / 2;
-    m2::PointD ptDiff = m_navigator.Screen().PixelRect().Center() - ptC;
-    pt1 += ptDiff;
-    pt2 += ptDiff;
-  }
-
-#ifdef DRAW_TOUCH_POINTS
-  m_informationDisplay.setDebugPoint(0, pt1);
-  m_informationDisplay.setDebugPoint(1, pt2);
-#endif
+  m2::PointD pt1, pt2;
+  CalcScalePoints(e, pt1, pt2);
 
   m_navigator.DoScale(pt1, pt2, ElapsedSeconds());
   if (m_renderPolicy)
     m_renderPolicy->DoScale();
-//  LOG(LINFO, ("DoScale", e.Pt1(), e.Pt2()));
 }
 
 void Framework::StopScale(ScaleEvent const & e)
 {
-  m2::PointD pt1 = m_navigator.ShiftPoint(e.Pt1());
-  m2::PointD pt2 = m_navigator.ShiftPoint(e.Pt2());
-
-  if ((m_locationState & location::State::EGps) && (m_centeringMode == ECenterOnly))
-  {
-    m2::PointD ptC = (pt1 + pt2) / 2;
-    m2::PointD ptDiff = m_navigator.Screen().PixelRect().Center() - ptC;
-    pt1 += ptDiff;
-    pt2 += ptDiff;
-  }
-
-#ifdef DRAW_TOUCH_POINTS
-  m_informationDisplay.setDebugPoint(0, m2::PointD(0, 0));
-  m_informationDisplay.setDebugPoint(0, m2::PointD(0, 0));
-#endif
+  m2::PointD pt1, pt2;
+  CalcScalePoints(e, pt1, pt2);
 
   m_navigator.StopScale(pt1, pt2, ElapsedSeconds());
   if (m_renderPolicy)
     m_renderPolicy->StopScale();
-//  LOG(LINFO, ("StopScale", e.Pt1(), e.Pt2()));
 }
+//@}
 
 search::Engine * Framework::GetSearchEngine() const
 {
diff --git a/map/framework.hpp b/map/framework.hpp
index c69d0619de..f0289e4b1e 100644
--- a/map/framework.hpp
+++ b/map/framework.hpp
@@ -89,7 +89,8 @@ protected:
   {
     EDoNothing,
     ECenterAndScale,
-    ECenterOnly
+    ECenterOnly,
+    ESkipLocationCentering
   };
 
   TGpsCenteringMode m_centeringMode;
@@ -157,9 +158,13 @@ public:
 
   storage::Storage & Storage() { return m_storage; }
 
+  /// @name GPS location updates routine.
+  //@{
+  void SkipLocationCentering();
   void OnLocationStatusChanged(location::TLocationStatus newStatus);
   void OnGpsUpdate(location::GpsInfo const & info);
   void OnCompassUpdate(location::CompassInfo const & info);
+  //@}
 
   void SetRenderPolicy(RenderPolicy * renderPolicy);
   RenderPolicy * GetRenderPolicy() const;
@@ -274,6 +279,9 @@ public:
 
   /// @name Drag implementation.
   //@{
+private:
+  m2::PointD GetPixelCenter() const;
+public:
   void StartDrag(DragEvent const & e);
   void DoDrag(DragEvent const & e);
   void StopDrag(DragEvent const & e);
@@ -292,6 +300,10 @@ public:
   void ScaleToPoint(ScaleToPointEvent const & e);
   void ScaleDefault(bool enlarge);
   void Scale(double scale);
+
+private:
+  void CalcScalePoints(ScaleEvent const & e, m2::PointD & pt1, m2::PointD & pt2) const;
+public:
   void StartScale(ScaleEvent const & e);
   void DoScale(ScaleEvent const & e);
   void StopScale(ScaleEvent const & e);