content/browser/android/overscroll_glow.cc

   1 // Copyright (c) 2013 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 "content/browser/android/overscroll_glow.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/threading/worker_pool.h"
  10 #include "cc/layers/image_layer.h"
  11 #include "content/browser/android/edge_effect.h"
  12 #include "skia/ext/image_operations.h"
  13 #include "ui/gfx/android/java_bitmap.h"
  14
  15 using std::max;
  16 using std::min;
  17
  18 namespace content {
  19
  20 namespace {
  21
  22 const float kEpsilon = 1e-3f;
  23 const int kScaledEdgeHeight = 12;
  24 const int kScaledGlowHeight = 64;
  25 const float kEdgeHeightAtMdpi = 12.f;
  26 const float kGlowHeightAtMdpi = 128.f;
  27
  28 SkBitmap CreateSkBitmapFromAndroidResource(const char* name, gfx::Size size) {
  29   base::android::ScopedJavaLocalRef<jobject> jobj =
  30       gfx::CreateJavaBitmapFromAndroidResource(name, size);
  31   if (jobj.is_null())
  32     return SkBitmap();
  33
  34   SkBitmap bitmap = CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(jobj.obj()));
  35   if (bitmap.isNull())
  36     return bitmap;
  37
  38   return skia::ImageOperations::Resize(
  39       bitmap, skia::ImageOperations::RESIZE_BOX, size.width(), size.height());
  40 }
  41
  42 class OverscrollResources {
  43  public:
  44   OverscrollResources() {
  45     TRACE_EVENT0("browser", "OverscrollResources::Create");
  46     edge_bitmap_ =
  47         CreateSkBitmapFromAndroidResource("android:drawable/overscroll_edge",
  48                                           gfx::Size(128, kScaledEdgeHeight));
  49     glow_bitmap_ =
  50         CreateSkBitmapFromAndroidResource("android:drawable/overscroll_glow",
  51                                           gfx::Size(128, kScaledGlowHeight));
  52   }
  53
  54   const SkBitmap& edge_bitmap() const { return edge_bitmap_; }
  55   const SkBitmap& glow_bitmap() const { return glow_bitmap_; }
  56
  57  private:
  58   SkBitmap edge_bitmap_;
  59   SkBitmap glow_bitmap_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(OverscrollResources);
  62 };
  63
  64 // Leaky to allow access from a worker thread.
  65 base::LazyInstance<OverscrollResources>::Leaky g_overscroll_resources =
  66     LAZY_INSTANCE_INITIALIZER;
  67
  68 scoped_refptr<cc::Layer> CreateImageLayer(const SkBitmap& bitmap) {
  69   scoped_refptr<cc::ImageLayer> layer = cc::ImageLayer::Create();
  70   layer->SetBitmap(bitmap);
  71   return layer;
  72 }
  73
  74 bool IsApproxZero(float value) {
  75   return std::abs(value) < kEpsilon;
  76 }
  77
  78 gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
  79   if (IsApproxZero(vector.x()))
  80     vector.set_x(0);
  81   if (IsApproxZero(vector.y()))
  82     vector.set_y(0);
  83   return vector;
  84 }
  85
  86 // Force loading of any necessary resources.  This function is thread-safe.
  87 void EnsureResources() {
  88   g_overscroll_resources.Get();
  89 }
  90
  91 } // namespace
  92
  93 scoped_ptr<OverscrollGlow> OverscrollGlow::Create(bool enabled) {
  94   // Don't block the main thread with effect resource loading during creation.
  95   // Effect instantiation is deferred until the effect overscrolls, in which
  96   // case the main thread may block until the resource has loaded.
  97   if (enabled && g_overscroll_resources == NULL)
  98     base::WorkerPool::PostTask(FROM_HERE, base::Bind(EnsureResources), true);
  99
 100   return make_scoped_ptr(new OverscrollGlow(enabled));
 101 }
 102
 103 OverscrollGlow::OverscrollGlow(bool enabled)
 104     : enabled_(enabled), initialized_(false) {}
 105
 106 OverscrollGlow::~OverscrollGlow() {
 107   Detach();
 108 }
 109
 110 void OverscrollGlow::Enable() {
 111   enabled_ = true;
 112 }
 113
 114 void OverscrollGlow::Disable() {
 115   if (!enabled_)
 116     return;
 117   enabled_ = false;
 118   if (!enabled_ && initialized_) {
 119     Detach();
 120     for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
 121       edge_effects_[i]->Finish();
 122   }
 123 }
 124
 125 bool OverscrollGlow::OnOverscrolled(cc::Layer* overscrolling_layer,
 126                                     base::TimeTicks current_time,
 127                                     gfx::Vector2dF accumulated_overscroll,
 128                                     gfx::Vector2dF overscroll_delta,
 129                                     gfx::Vector2dF velocity) {
 130   DCHECK(overscrolling_layer);
 131
 132   if (!enabled_)
 133     return false;
 134
 135   // The size of the glow determines the relative effect of the inputs; an
 136   // empty-sized effect is effectively disabled.
 137   if (display_params_.size.IsEmpty())
 138     return false;
 139
 140   // Ignore sufficiently small values that won't meaningfuly affect animation.
 141   overscroll_delta = ZeroSmallComponents(overscroll_delta);
 142   if (overscroll_delta.IsZero()) {
 143     if (initialized_) {
 144       Release(current_time);
 145       UpdateLayerAttachment(overscrolling_layer);
 146     }
 147     return NeedsAnimate();
 148   }
 149
 150   if (!InitializeIfNecessary())
 151     return false;
 152
 153   gfx::Vector2dF old_overscroll = accumulated_overscroll - overscroll_delta;
 154   bool x_overscroll_started =
 155       !IsApproxZero(overscroll_delta.x()) && IsApproxZero(old_overscroll.x());
 156   bool y_overscroll_started =
 157       !IsApproxZero(overscroll_delta.y()) && IsApproxZero(old_overscroll.y());
 158
 159   if (x_overscroll_started)
 160     ReleaseAxis(AXIS_X, current_time);
 161   if (y_overscroll_started)
 162     ReleaseAxis(AXIS_Y, current_time);
 163
 164   velocity = ZeroSmallComponents(velocity);
 165   if (!velocity.IsZero())
 166     Absorb(current_time, velocity, x_overscroll_started, y_overscroll_started);
 167   else
 168     Pull(current_time, overscroll_delta);
 169
 170   UpdateLayerAttachment(overscrolling_layer);
 171   return NeedsAnimate();
 172 }
 173
 174 bool OverscrollGlow::Animate(base::TimeTicks current_time) {
 175   if (!NeedsAnimate()) {
 176     Detach();
 177     return false;
 178   }
 179
 180   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 181     if (edge_effects_[i]->Update(current_time)) {
 182       edge_effects_[i]->ApplyToLayers(
 183           display_params_.size,
 184           static_cast<EdgeEffect::Edge>(i),
 185           kEdgeHeightAtMdpi * display_params_.device_scale_factor,
 186           kGlowHeightAtMdpi * display_params_.device_scale_factor,
 187           display_params_.edge_offsets[i]);
 188     }
 189   }
 190
 191   if (!NeedsAnimate()) {
 192     Detach();
 193     return false;
 194   }
 195
 196   return true;
 197 }
 198
 199 void OverscrollGlow::UpdateDisplayParameters(const DisplayParameters& params) {
 200   display_params_ = params;
 201 }
 202
 203 bool OverscrollGlow::NeedsAnimate() const {
 204   if (!enabled_ || !initialized_)
 205     return false;
 206   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 207     if (!edge_effects_[i]->IsFinished())
 208       return true;
 209   }
 210   return false;
 211 }
 212
 213 void OverscrollGlow::UpdateLayerAttachment(cc::Layer* parent) {
 214   DCHECK(parent);
 215   if (!root_layer_)
 216     return;
 217
 218   if (!NeedsAnimate()) {
 219     Detach();
 220     return;
 221   }
 222
 223   if (root_layer_->parent() != parent)
 224     parent->AddChild(root_layer_);
 225 }
 226
 227 void OverscrollGlow::Detach() {
 228   if (root_layer_)
 229     root_layer_->RemoveFromParent();
 230 }
 231
 232 bool OverscrollGlow::InitializeIfNecessary() {
 233   DCHECK(enabled_);
 234   if (initialized_)
 235     return true;
 236
 237   const SkBitmap& edge = g_overscroll_resources.Get().edge_bitmap();
 238   const SkBitmap& glow = g_overscroll_resources.Get().glow_bitmap();
 239   if (edge.isNull() || glow.isNull()) {
 240     Disable();
 241     return false;
 242   }
 243
 244   DCHECK(!root_layer_);
 245   root_layer_ = cc::Layer::Create();
 246   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 247     scoped_refptr<cc::Layer> edge_layer = CreateImageLayer(edge);
 248     scoped_refptr<cc::Layer> glow_layer = CreateImageLayer(glow);
 249     root_layer_->AddChild(edge_layer);
 250     root_layer_->AddChild(glow_layer);
 251     edge_effects_[i] = make_scoped_ptr(new EdgeEffect(edge_layer, glow_layer));
 252   }
 253
 254   initialized_ = true;
 255   return true;
 256 }
 257
 258 void OverscrollGlow::Pull(base::TimeTicks current_time,
 259                           gfx::Vector2dF overscroll_delta) {
 260   DCHECK(enabled_ && initialized_);
 261   overscroll_delta = ZeroSmallComponents(overscroll_delta);
 262   if (overscroll_delta.IsZero())
 263     return;
 264
 265   gfx::Vector2dF overscroll_pull =
 266       gfx::ScaleVector2d(overscroll_delta,
 267                          1.f / display_params_.size.width(),
 268                          1.f / display_params_.size.height());
 269   float edge_overscroll_pull[EdgeEffect::EDGE_COUNT] = {
 270       min(overscroll_pull.y(), 0.f),  // Top
 271       min(overscroll_pull.x(), 0.f),  // Left
 272       max(overscroll_pull.y(), 0.f),  // Bottom
 273       max(overscroll_pull.x(), 0.f)   // Right
 274   };
 275
 276   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 277     if (!edge_overscroll_pull[i])
 278       continue;
 279
 280     edge_effects_[i]->Pull(current_time, std::abs(edge_overscroll_pull[i]));
 281     GetOppositeEdge(i)->Release(current_time);
 282   }
 283 }
 284
 285 void OverscrollGlow::Absorb(base::TimeTicks current_time,
 286                             gfx::Vector2dF velocity,
 287                             bool x_overscroll_started,
 288                             bool y_overscroll_started) {
 289   DCHECK(enabled_ && initialized_);
 290   if (velocity.IsZero())
 291     return;
 292
 293   // Only trigger on initial overscroll at a non-zero velocity
 294   const float overscroll_velocities[EdgeEffect::EDGE_COUNT] = {
 295       y_overscroll_started ? min(velocity.y(), 0.f) : 0,  // Top
 296       x_overscroll_started ? min(velocity.x(), 0.f) : 0,  // Left
 297       y_overscroll_started ? max(velocity.y(), 0.f) : 0,  // Bottom
 298       x_overscroll_started ? max(velocity.x(), 0.f) : 0   // Right
 299   };
 300
 301   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 302     if (!overscroll_velocities[i])
 303       continue;
 304
 305     edge_effects_[i]->Absorb(current_time, std::abs(overscroll_velocities[i]));
 306     GetOppositeEdge(i)->Release(current_time);
 307   }
 308 }
 309
 310 void OverscrollGlow::Release(base::TimeTicks current_time) {
 311   DCHECK(initialized_);
 312   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
 313     edge_effects_[i]->Release(current_time);
 314 }
 315
 316 void OverscrollGlow::ReleaseAxis(Axis axis, base::TimeTicks current_time) {
 317   DCHECK(initialized_);
 318   switch (axis) {
 319     case AXIS_X:
 320       edge_effects_[EdgeEffect::EDGE_LEFT]->Release(current_time);
 321       edge_effects_[EdgeEffect::EDGE_RIGHT]->Release(current_time);
 322       break;
 323     case AXIS_Y:
 324       edge_effects_[EdgeEffect::EDGE_TOP]->Release(current_time);
 325       edge_effects_[EdgeEffect::EDGE_BOTTOM]->Release(current_time);
 326       break;
 327   };
 328 }
 329
 330 EdgeEffect* OverscrollGlow::GetOppositeEdge(int edge_index) {
 331   DCHECK(initialized_);
 332   return edge_effects_[(edge_index + 2) % EdgeEffect::EDGE_COUNT].get();
 333 }
 334
 335 OverscrollGlow::DisplayParameters::DisplayParameters()
 336     : device_scale_factor(1) {
 337   edge_offsets[0] = edge_offsets[1] = edge_offsets[2] = edge_offsets[3] = 0.f;
 338 }
 339
 340 }  // namespace content