src/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 "cc/layers/image_layer.h"
  10 #include "content/browser/android/edge_effect.h"
  11 #include "ui/gfx/android/java_bitmap.h"
  12
  13 using std::max;
  14 using std::min;
  15
  16 namespace content {
  17
  18 namespace {
  19
  20 const float kEpsilon = 1e-3f;
  21
  22 class OverscrollResources {
  23  public:
  24   OverscrollResources() {
  25     TRACE_EVENT0("browser", "OverscrollResources::Create");
  26     edge_bitmap_ =
  27         gfx::CreateSkBitmapFromResource("android:drawable/overscroll_edge",
  28                                         gfx::Size(128, 12));
  29     glow_bitmap_ =
  30         gfx::CreateSkBitmapFromResource("android:drawable/overscroll_glow",
  31                                         gfx::Size(128, 64));
  32   }
  33
  34   const SkBitmap& edge_bitmap() { return edge_bitmap_; }
  35   const SkBitmap& glow_bitmap() { return glow_bitmap_; }
  36
  37  private:
  38   SkBitmap edge_bitmap_;
  39   SkBitmap glow_bitmap_;
  40
  41   DISALLOW_COPY_AND_ASSIGN(OverscrollResources);
  42 };
  43
  44 // Leaky to allow access from a worker thread.
  45 base::LazyInstance<OverscrollResources>::Leaky g_overscroll_resources =
  46     LAZY_INSTANCE_INITIALIZER;
  47
  48 scoped_refptr<cc::Layer> CreateImageLayer(const SkBitmap& bitmap) {
  49   scoped_refptr<cc::ImageLayer> layer = cc::ImageLayer::Create();
  50   layer->SetBitmap(bitmap);
  51   return layer;
  52 }
  53
  54 bool IsApproxZero(float value) {
  55   return std::abs(value) < kEpsilon;
  56 }
  57
  58 gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
  59   if (IsApproxZero(vector.x()))
  60     vector.set_x(0);
  61   if (IsApproxZero(vector.y()))
  62     vector.set_y(0);
  63   return vector;
  64 }
  65
  66 } // namespace
  67
  68 scoped_ptr<OverscrollGlow> OverscrollGlow::Create(bool enabled,
  69                                                   gfx::SizeF size) {
  70   const SkBitmap& edge = g_overscroll_resources.Get().edge_bitmap();
  71   const SkBitmap& glow = g_overscroll_resources.Get().glow_bitmap();
  72   if (edge.isNull() || glow.isNull())
  73     return scoped_ptr<OverscrollGlow>();
  74
  75   return make_scoped_ptr(new OverscrollGlow(enabled, size, edge, glow));
  76 }
  77
  78 void OverscrollGlow::EnsureResources() {
  79   g_overscroll_resources.Get();
  80 }
  81
  82 OverscrollGlow::OverscrollGlow(bool enabled,
  83                                gfx::SizeF size,
  84                                const SkBitmap& edge,
  85                                const SkBitmap& glow)
  86   : enabled_(enabled),
  87     size_(size),
  88     horizontal_overscroll_enabled_(true),
  89     vertical_overscroll_enabled_(true),
  90     root_layer_(cc::Layer::Create()) {
  91   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
  92     scoped_refptr<cc::Layer> edge_layer = CreateImageLayer(edge);
  93     scoped_refptr<cc::Layer> glow_layer = CreateImageLayer(glow);
  94     root_layer_->AddChild(edge_layer);
  95     root_layer_->AddChild(glow_layer);
  96     edge_effects_[i] = make_scoped_ptr(new EdgeEffect(edge_layer, glow_layer));
  97   }
  98 }
  99
 100 OverscrollGlow::~OverscrollGlow() {
 101   root_layer_->RemoveFromParent();
 102 }
 103
 104 void OverscrollGlow::OnOverscrolled(base::TimeTicks current_time,
 105                                     gfx::Vector2dF overscroll,
 106                                     gfx::Vector2dF velocity) {
 107   if (!enabled_)
 108     return;
 109
 110   // The size of the glow determines the relative effect of the inputs; an
 111   // empty-sized effect is effectively disabled.
 112   if (size_.IsEmpty())
 113     return;
 114
 115   if (!horizontal_overscroll_enabled_) {
 116     overscroll.set_x(0);
 117     velocity.set_x(0);
 118   }
 119   if (!vertical_overscroll_enabled_) {
 120     overscroll.set_y(0);
 121     velocity.set_y(0);
 122   }
 123
 124   // Ignore sufficiently small values that won't meaningfuly affect animation.
 125   overscroll = ZeroSmallComponents(overscroll);
 126   velocity = ZeroSmallComponents(velocity);
 127
 128   if (overscroll.IsZero()) {
 129     Release(current_time);
 130     return;
 131   }
 132
 133   if (!velocity.IsZero()) {
 134     // Release effects if scrolling has changed directions.
 135     if (velocity.x() * old_velocity_.x() < 0)
 136       ReleaseAxis(AXIS_X, current_time);
 137     if (velocity.y() * old_velocity_.y() < 0)
 138       ReleaseAxis(AXIS_Y, current_time);
 139
 140     Absorb(current_time, velocity, overscroll, old_overscroll_);
 141   } else {
 142     // Release effects when overscroll accumulation violates monotonicity.
 143     if (overscroll.x() * old_overscroll_.x() < 0 ||
 144         std::abs(overscroll.x()) < std::abs(old_overscroll_.x()))
 145       ReleaseAxis(AXIS_X, current_time);
 146     if (overscroll.y() * old_overscroll_.y() < 0 ||
 147         std::abs(overscroll.y()) < std::abs(old_overscroll_.y()))
 148       ReleaseAxis(AXIS_Y, current_time);
 149
 150     Pull(current_time, overscroll - old_overscroll_);
 151   }
 152
 153   old_velocity_ = velocity;
 154   old_overscroll_ = overscroll;
 155 }
 156
 157 bool OverscrollGlow::Animate(base::TimeTicks current_time) {
 158   if (!NeedsAnimate())
 159     return false;
 160
 161   const gfx::SizeF sizes[EdgeEffect::EDGE_COUNT] = {
 162     size_, gfx::SizeF(size_.height(), size_.width()),
 163     size_, gfx::SizeF(size_.height(), size_.width())
 164   };
 165
 166   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 167     if (edge_effects_[i]->Update(current_time)) {
 168       edge_effects_[i]->ApplyToLayers(sizes[i],
 169                                       static_cast<EdgeEffect::Edge>(i));
 170     }
 171   }
 172
 173   return NeedsAnimate();
 174 }
 175
 176 void OverscrollGlow::SetEnabled(bool enabled) {
 177   if (enabled_ == enabled)
 178     return;
 179   enabled_ = enabled;
 180   if (!enabled_) {
 181     for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
 182       edge_effects_[i]->Finish();
 183   }
 184 }
 185
 186 bool OverscrollGlow::NeedsAnimate() const {
 187   if (!enabled_)
 188     return false;
 189   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 190     if (!edge_effects_[i]->IsFinished())
 191       return true;
 192   }
 193   return false;
 194 }
 195
 196 void OverscrollGlow::Pull(base::TimeTicks current_time,
 197                           gfx::Vector2dF overscroll_delta) {
 198   overscroll_delta = ZeroSmallComponents(overscroll_delta);
 199   if (overscroll_delta.IsZero())
 200     return;
 201
 202   gfx::Vector2dF overscroll_pull = gfx::ScaleVector2d(overscroll_delta,
 203                                                       1.f / size_.width(),
 204                                                       1.f / size_.height());
 205   float edge_overscroll_pull[EdgeEffect::EDGE_COUNT] = {
 206     min(overscroll_pull.y(), 0.f), // Top
 207     min(overscroll_pull.x(), 0.f), // Left
 208     max(overscroll_pull.y(), 0.f), // Bottom
 209     max(overscroll_pull.x(), 0.f)  // Right
 210   };
 211
 212   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 213     if (!edge_overscroll_pull[i])
 214       continue;
 215
 216     edge_effects_[i]->Pull(current_time, std::abs(edge_overscroll_pull[i]));
 217     GetOppositeEdge(i)->Release(current_time);
 218   }
 219 }
 220
 221 void OverscrollGlow::Absorb(base::TimeTicks current_time,
 222                             gfx::Vector2dF velocity,
 223                             gfx::Vector2dF overscroll,
 224                             gfx::Vector2dF old_overscroll) {
 225   if (overscroll.IsZero() || velocity.IsZero())
 226     return;
 227
 228   // Only trigger on initial overscroll at a non-zero velocity
 229   const float overscroll_velocities[EdgeEffect::EDGE_COUNT] = {
 230     old_overscroll.y() >= 0 && overscroll.y() < 0 ? min(velocity.y(), 0.f) : 0,
 231     old_overscroll.x() >= 0 && overscroll.x() < 0 ? min(velocity.x(), 0.f) : 0,
 232     old_overscroll.y() <= 0 && overscroll.y() > 0 ? max(velocity.y(), 0.f) : 0,
 233     old_overscroll.x() <= 0 && overscroll.x() > 0 ? max(velocity.x(), 0.f) : 0
 234   };
 235
 236   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 237     if (!overscroll_velocities[i])
 238       continue;
 239
 240     edge_effects_[i]->Absorb(current_time, std::abs(overscroll_velocities[i]));
 241     GetOppositeEdge(i)->Release(current_time);
 242   }
 243 }
 244
 245 void OverscrollGlow::Release(base::TimeTicks current_time) {
 246   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 247     edge_effects_[i]->Release(current_time);
 248   }
 249   old_overscroll_ = old_velocity_ = gfx::Vector2dF();
 250 }
 251
 252 void OverscrollGlow::ReleaseAxis(Axis axis, base::TimeTicks current_time) {
 253   switch (axis) {
 254     case AXIS_X:
 255       edge_effects_[EdgeEffect::EDGE_LEFT]->Release(current_time);
 256       edge_effects_[EdgeEffect::EDGE_RIGHT]->Release(current_time);
 257       old_overscroll_.set_x(0);
 258       old_velocity_.set_x(0);
 259       break;
 260     case AXIS_Y:
 261       edge_effects_[EdgeEffect::EDGE_TOP]->Release(current_time);
 262       edge_effects_[EdgeEffect::EDGE_BOTTOM]->Release(current_time);
 263       old_overscroll_.set_y(0);
 264       old_velocity_.set_y(0);
 265       break;
 266   };
 267 }
 268
 269 EdgeEffect* OverscrollGlow::GetOppositeEdge(int edge_index) {
 270   return edge_effects_[(edge_index + 2) % EdgeEffect::EDGE_COUNT].get();
 271 }
 272
 273 }  // namespace content
 274