ui/gfx/android/view_configuration.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/android/view_configuration.h"
   6
   7 #include "base/android/jni_android.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/threading/non_thread_safe.h"
  10 #include "jni/ViewConfigurationHelper_jni.h"
  11
  12 using base::android::AttachCurrentThread;
  13 using base::android::GetApplicationContext;
  14
  15 namespace gfx {
  16
  17 namespace {
  18
  19 struct ViewConfigurationData {
  20   ViewConfigurationData()
  21       : double_tap_timeout_in_ms_(0),
  22         long_press_timeout_in_ms_(0),
  23         tap_timeout_in_ms_(0),
  24         scroll_friction_(1.f),
  25         max_fling_velocity_in_pixels_s_(0),
  26         min_fling_velocity_in_pixels_s_(0),
  27         touch_slop_in_pixels_(0),
  28         double_tap_slop_in_pixels_(0),
  29         min_scaling_span_in_pixels_(0),
  30         min_scaling_touch_major_in_pixels_(0) {
  31     JNIEnv* env = AttachCurrentThread();
  32     j_view_configuration_helper_.Reset(
  33         Java_ViewConfigurationHelper_createWithListener(
  34             env, base::android::GetApplicationContext()));
  35
  36     double_tap_timeout_in_ms_ =
  37         Java_ViewConfigurationHelper_getDoubleTapTimeout(env);
  38     long_press_timeout_in_ms_ =
  39         Java_ViewConfigurationHelper_getLongPressTimeout(env);
  40     tap_timeout_in_ms_ = Java_ViewConfigurationHelper_getTapTimeout(env);
  41     scroll_friction_ = Java_ViewConfigurationHelper_getScrollFriction(env);
  42     should_use_touch_major_in_scaling_span_ =
  43         Java_ViewConfigurationHelper_shouldUseTouchMajorInScalingSpan(env);
  44
  45     jobject obj = j_view_configuration_helper_.obj();
  46     Update(
  47         Java_ViewConfigurationHelper_getScaledMaximumFlingVelocity(env, obj),
  48         Java_ViewConfigurationHelper_getScaledMinimumFlingVelocity(env, obj),
  49         Java_ViewConfigurationHelper_getScaledTouchSlop(env, obj),
  50         Java_ViewConfigurationHelper_getScaledDoubleTapSlop(env, obj),
  51         Java_ViewConfigurationHelper_getScaledMinScalingSpan(env, obj),
  52         Java_ViewConfigurationHelper_getScaledMinScalingTouchMajor(env, obj));
  53   }
  54
  55   ~ViewConfigurationData() {}
  56
  57   void SynchronizedUpdate(int scaled_maximum_fling_velocity,
  58                           int scaled_minimum_fling_velocity,
  59                           int scaled_touch_slop,
  60                           int scaled_double_tap_slop,
  61                           int scaled_min_scaling_span,
  62                           int scaled_min_scaling_touch_major) {
  63     base::AutoLock autolock(lock_);
  64     Update(scaled_maximum_fling_velocity,
  65            scaled_minimum_fling_velocity,
  66            scaled_touch_slop,
  67            scaled_double_tap_slop,
  68            scaled_min_scaling_span,
  69            scaled_min_scaling_touch_major);
  70   }
  71
  72   int double_tap_timeout_in_ms() const { return double_tap_timeout_in_ms_; }
  73   int long_press_timeout_in_ms() const { return long_press_timeout_in_ms_; }
  74   int tap_timeout_in_ms() const { return tap_timeout_in_ms_; }
  75   float scroll_friction() const { return scroll_friction_; }
  76   bool should_use_touch_major_in_scaling_span() const {
  77     return should_use_touch_major_in_scaling_span_;
  78   }
  79
  80   int max_fling_velocity_in_pixels_s() {
  81     base::AutoLock autolock(lock_);
  82     return max_fling_velocity_in_pixels_s_;
  83   }
  84
  85   int min_fling_velocity_in_pixels_s() {
  86     base::AutoLock autolock(lock_);
  87     return min_fling_velocity_in_pixels_s_;
  88   }
  89
  90   int touch_slop_in_pixels() {
  91     base::AutoLock autolock(lock_);
  92     return touch_slop_in_pixels_;
  93   }
  94
  95   int double_tap_slop_in_pixels() {
  96     base::AutoLock autolock(lock_);
  97     return double_tap_slop_in_pixels_;
  98   }
  99
 100   int min_scaling_span_in_pixels() {
 101     base::AutoLock autolock(lock_);
 102     return min_scaling_span_in_pixels_;
 103   }
 104
 105   int min_scaling_touch_major_in_pixels() {
 106     base::AutoLock autolock(lock_);
 107     return min_scaling_touch_major_in_pixels_;
 108   }
 109
 110  private:
 111   void Update(int scaled_maximum_fling_velocity,
 112               int scaled_minimum_fling_velocity,
 113               int scaled_touch_slop,
 114               int scaled_double_tap_slop,
 115               int scaled_min_scaling_span,
 116               int scaled_min_scaling_touch_major) {
 117     DCHECK_LE(scaled_minimum_fling_velocity, scaled_maximum_fling_velocity);
 118     max_fling_velocity_in_pixels_s_ = scaled_maximum_fling_velocity;
 119     min_fling_velocity_in_pixels_s_ = scaled_minimum_fling_velocity;
 120     touch_slop_in_pixels_ = scaled_touch_slop;
 121     double_tap_slop_in_pixels_ = scaled_double_tap_slop;
 122     min_scaling_span_in_pixels_ = scaled_min_scaling_span;
 123     min_scaling_touch_major_in_pixels_ = scaled_min_scaling_touch_major;
 124   }
 125
 126   base::Lock lock_;
 127   base::android::ScopedJavaGlobalRef<jobject> j_view_configuration_helper_;
 128
 129   // These values will remain constant throughout the lifetime of the app, so
 130   // read-access needn't be synchronized.
 131   int double_tap_timeout_in_ms_;
 132   int long_press_timeout_in_ms_;
 133   int tap_timeout_in_ms_;
 134   float scroll_friction_;
 135   bool should_use_touch_major_in_scaling_span_;
 136
 137   // These values may vary as view-specific parameters (DPI scale) are changed,
 138   // so read/write access must be synchronized.
 139   int max_fling_velocity_in_pixels_s_;
 140   int min_fling_velocity_in_pixels_s_;
 141   int touch_slop_in_pixels_;
 142   int double_tap_slop_in_pixels_;
 143   int min_scaling_span_in_pixels_;
 144   int min_scaling_touch_major_in_pixels_;
 145
 146  private:
 147   DISALLOW_COPY_AND_ASSIGN(ViewConfigurationData);
 148 };
 149
 150 // Leaky to allow access from any thread.
 151 base::LazyInstance<ViewConfigurationData>::Leaky g_view_configuration =
 152     LAZY_INSTANCE_INITIALIZER;
 153
 154 }  // namespace
 155
 156 static void UpdateSharedViewConfiguration(JNIEnv* env,
 157                                           jobject obj,
 158                                           jint scaled_maximum_fling_velocity,
 159                                           jint scaled_minimum_fling_velocity,
 160                                           jint scaled_touch_slop,
 161                                           jint scaled_double_tap_slop,
 162                                           jint scaled_min_scaling_span,
 163                                           jint scaled_min_scaling_touch_major) {
 164   g_view_configuration.Get().SynchronizedUpdate(scaled_maximum_fling_velocity,
 165                                                 scaled_minimum_fling_velocity,
 166                                                 scaled_touch_slop,
 167                                                 scaled_double_tap_slop,
 168                                                 scaled_min_scaling_span,
 169                                                 scaled_min_scaling_touch_major);
 170 }
 171
 172 int ViewConfiguration::GetDoubleTapTimeoutInMs() {
 173   return g_view_configuration.Get().double_tap_timeout_in_ms();
 174 }
 175
 176 int ViewConfiguration::GetLongPressTimeoutInMs() {
 177   return g_view_configuration.Get().long_press_timeout_in_ms();
 178 }
 179
 180 int ViewConfiguration::GetTapTimeoutInMs() {
 181   return g_view_configuration.Get().tap_timeout_in_ms();
 182 }
 183
 184 float ViewConfiguration::GetScrollFriction() {
 185   return g_view_configuration.Get().scroll_friction();
 186 }
 187
 188 int ViewConfiguration::GetMaximumFlingVelocityInPixelsPerSecond() {
 189   return g_view_configuration.Get().max_fling_velocity_in_pixels_s();
 190 }
 191
 192 int ViewConfiguration::GetMinimumFlingVelocityInPixelsPerSecond() {
 193   return g_view_configuration.Get().min_fling_velocity_in_pixels_s();
 194 }
 195
 196 int ViewConfiguration::GetTouchSlopInPixels() {
 197   return g_view_configuration.Get().touch_slop_in_pixels();
 198 }
 199
 200 int ViewConfiguration::GetDoubleTapSlopInPixels() {
 201   return g_view_configuration.Get().double_tap_slop_in_pixels();
 202 }
 203
 204 int ViewConfiguration::GetMinScalingSpanInPixels() {
 205   return g_view_configuration.Get().min_scaling_span_in_pixels();
 206 }
 207
 208 int ViewConfiguration::GetMinScalingTouchMajorInPixels() {
 209   return g_view_configuration.Get().min_scaling_touch_major_in_pixels();
 210 }
 211
 212 bool ViewConfiguration::ShouldUseTouchMajorInScalingSpan() {
 213   return g_view_configuration.Get().should_use_touch_major_in_scaling_span();
 214 }
 215
 216 bool ViewConfiguration::RegisterViewConfiguration(JNIEnv* env) {
 217   return RegisterNativesImpl(env);
 218 }
 219
 220 }  // namespace gfx