[Android] Add a native pull-to-refresh overscroll effect

content/browser/android/overscroll_refresh.cc

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/android/overscroll_refresh.h"
+
+#include "cc/layers/ui_resource_layer.h"
+#include "cc/trees/layer_tree_host.h"
+#include "content/browser/android/animation_utils.h"
+#include "ui/base/android/system_ui_resource_manager.h"
+
+using std::max;
+using std::min;
+
+namespace content {
+namespace {
+
+const ui::SystemUIResourceType kIdleResourceType = ui::OVERSCROLL_REFRESH_IDLE;
+const ui::SystemUIResourceType kActiveResourceType =
+    ui::OVERSCROLL_REFRESH_ACTIVE;
+
+// Animation duration after the effect is released without triggering a refresh.
+const int kRecedeTimeMs = 300;
+
+// Animation duration after the effect is released and triggers a refresh.
+const int kActivationTimeMs = 1000;
+
+// Max animation duration after the effect is released and triggers a refresh.
+const int kMaxActivationTimeMs = kActivationTimeMs * 3;
+
+// Animation duration after the refresh activated phase has completed.
+const int kActivationRecedeTimeMs = 300;
+
+// Useful for avoiding accidental triggering when a scroll janks (is delayed),
+// capping the impulse per event.
+const float kMaxNormalizedDeltaPerPull = .05f;
+
+// Input threshold required to activate the refresh.
+const float kPullActivationThreshold = .25f;

[Ted C, 2014/10/31 23:52:05]

What is this a percentage of?  Screen size?  If so, I think it would be odd to
have to pull down more or less depending on if you rotated your device.

[jdduke (slow), 2014/11/06 00:10:37]

I think it's important to be at least somewhat coupled to screen size, but maybe
we should just use the smaller of the two dimensions to make it consistent?

[Ted C, 2014/11/06 19:25:40]

In general, we should match the refresh widget used in the newer google apps. 
Capping it to the smaller of the two "seems" reasonable to me.

[jdduke (slow), 2014/11/07 18:33:44]

Yeah, they use a threshold invariant to the orientation. V2 of this will have me
more faithfully emulate the look (growing arrows, etc..) of google apps.

+
+// Input threshold required to start glowing.
+const float kGlowActivationThreshold = kPullActivationThreshold * 0.85f;
+
+// Maximum height of the effect relative to the content height.
+const float kMaxRelativeHeight = .3f;
+
+// Minimum alpha for the effect layer.
+const float kMinAlpha = 0.25f;
+
+// Controls spin velocity.
+const float kPullRotationMultiplier = 180.f * (1.f / kPullActivationThreshold);
+
+const float kEpsilon = 0.005f;
+
+void UpdateLayer(cc::UIResourceLayer* layer,
+                 cc::Layer* parent,
+                 cc::UIResourceId res_id,
+                 const gfx::SizeF& viewport_size,
+                 float relative_offset,
+                 float opacity,
+                 float rotation) {
+  // An empty window size, while meaningless, is also relatively harmless, and
+  // will simply prevent any drawing of the layers.
+  if (viewport_size.IsEmpty()) {
+    layer->SetIsDrawable(false);
+    return;
+  }
+
+  if (!res_id) {
+    layer->SetIsDrawable(false);
+    return;
+  }
+
+  if (opacity == 0) {
+    layer->SetIsDrawable(false);
+    layer->SetOpacity(0);
+    return;
+  }
+
+  if (layer->parent() != parent)
+    parent->AddChild(layer);
+
+  if (!layer->layer_tree_host())
+    return;
+
+  gfx::Size image_size = layer->layer_tree_host()->GetUIResourceSize(res_id);
+  layer->SetUIResourceId(res_id);
+  layer->SetIsDrawable(true);
+  layer->SetTransformOrigin(
+      gfx::Point3F(image_size.width() * 0.5f, image_size.height() * 0.5f, 0));
+  layer->SetBounds(image_size);
+  layer->SetContentsOpaque(false);
+  layer->SetOpacity(Clamp(opacity, 0.f, 1.f));
+
+  float offset_x = (viewport_size.width() - image_size.width()) * 0.5f;
+  float offset_y =
+      Damp(relative_offset, 1.f) * viewport_size.height() * kMaxRelativeHeight -
+      image_size.height();
+  gfx::Transform transform;
+  transform.Translate(offset_x, offset_y);
+  transform.Rotate(rotation);
+  layer->SetTransform(transform);
+}
+
+}  // namespace
+
+class OverscrollRefresh::Effect {
+ public:
+  Effect(ui::SystemUIResourceManager* resource_manager)
+      : resource_manager_(resource_manager),
+        idle_layer_(cc::UIResourceLayer::Create()),
+        active_layer_(cc::UIResourceLayer::Create()),
+        idle_alpha_(0),
+        active_alpha_(0),
+        offset_(0),
+        rotation_(0),
+        idle_alpha_start_(0),
+        idle_alpha_finish_(0),
+        active_alpha_start_(0),
+        active_alpha_finish_(0),
+        offset_start_(0),
+        offset_finish_(0),
+        rotation_start_(0),
+        rotation_finish_(0),
+        state_(STATE_IDLE) {
+    idle_layer_->SetIsDrawable(false);
+    active_layer_->SetIsDrawable(false);
+  }
+
+  ~Effect() { Detach(); }
+
+  void Pull(float normalized_delta) {
+    if (state_ != STATE_PULL)
+      offset_ = 0;
+
+    state_ = STATE_PULL;
+
+    normalized_delta = Clamp(normalized_delta,
+                             -kMaxNormalizedDeltaPerPull,
+                             kMaxNormalizedDeltaPerPull);
+
+    offset_ += normalized_delta;
+    offset_ = Clamp(offset_, 0.f, 1.f);
+
+    idle_alpha_ =
+        kMinAlpha + (1.f - kMinAlpha) * offset_ / kGlowActivationThreshold;
+    active_alpha_ = (offset_ - kGlowActivationThreshold) /
+                    (kPullActivationThreshold - kGlowActivationThreshold);
+    idle_alpha_ = Clamp(idle_alpha_, 0.f, 1.f);
+    active_alpha_ = Clamp(active_alpha_, 0.f, 1.f);
+
+    rotation_ = kPullRotationMultiplier * offset_;
+  }
+
+  bool Update(base::TimeTicks current_time, bool is_triggered_refresh_active) {
+    if (IsFinished())
+      return false;
+
+    if (state_ == STATE_PULL)
+      return true;
+
+    const double dt = (current_time - start_time_).InMilliseconds();
+    const double t = min(dt / duration_.InMilliseconds(), 1.);
+    const float interp = static_cast<float>(Damp(t, 1.));
+
+    idle_alpha_ = Lerp(idle_alpha_start_, idle_alpha_finish_, interp);
+    active_alpha_ = Lerp(active_alpha_start_, active_alpha_finish_, interp);
+    offset_ = Lerp(offset_start_, offset_finish_, interp);
+    rotation_ = Lerp(rotation_start_, rotation_finish_, interp);
+
+    if (t < 1.f - kEpsilon)
+      return true;
+
+    switch (state_) {
+      case STATE_IDLE:
+      case STATE_PULL:
+        NOTREACHED() << "Invalidate state for animation.";
+        break;
+      case STATE_ACTIVATED:
+        start_time_ = current_time;
+        if (is_triggered_refresh_active &&
+            (current_time - activated_start_time_ <
+             base::TimeDelta::FromMilliseconds(kMaxActivationTimeMs))) {
+          offset_start_ = offset_finish_ = offset_;
+          rotation_start_ = rotation_;
+          rotation_finish_ = rotation_start_ + 360.f;
+          break;
+        }
+        state_ = STATE_ACTIVATED_RECEDE;
+        duration_ = base::TimeDelta::FromMilliseconds(kActivationRecedeTimeMs);
+        idle_alpha_start_ = idle_alpha_;
+        active_alpha_start_ = active_alpha_;
+        idle_alpha_finish_ = 0;
+        active_alpha_finish_ = 0;
+        rotation_start_ = rotation_finish_ = rotation_;
+        offset_start_ = offset_finish_ = offset_;
+        break;
+      case STATE_ACTIVATED_RECEDE:
+        Finish();
+        break;
+      case STATE_RECEDE:
+        Finish();
+        break;
+    };
+
+    return !IsFinished();
+  }
+
+  bool Release(base::TimeTicks current_time, bool allow_activation) {
+    if (state_ != STATE_ACTIVATED && state_ != STATE_PULL)
+      return false;
+
+    if (state_ == STATE_ACTIVATED && allow_activation)
+      return false;
+
+    start_time_ = current_time;
+    idle_alpha_start_ = idle_alpha_;
+    active_alpha_start_ = active_alpha_;
+    offset_start_ = offset_;
+    rotation_start_ = rotation_;
+
+    if (offset_ < kPullActivationThreshold || !allow_activation) {
+      state_ = STATE_RECEDE;
+      duration_ = base::TimeDelta::FromMilliseconds(kRecedeTimeMs);
+      idle_alpha_finish_ = 0;
+      active_alpha_finish_ = 0;
+      offset_finish_ = 0;
+      rotation_finish_ = 0;
+      return false;
+    }
+
+    state_ = STATE_ACTIVATED;
+    duration_ = base::TimeDelta::FromMilliseconds(kActivationTimeMs);
+    activated_start_time_ = current_time;
+    idle_alpha_finish_ = idle_alpha_start_;
+    active_alpha_finish_ = active_alpha_start_;
+    offset_finish_ = kPullActivationThreshold;
+    rotation_finish_ = rotation_start_ + 360.f;
+    return true;
+  }
+
+  void Finish() {
+    Detach();
+    idle_layer_->SetIsDrawable(false);
+    active_layer_->SetIsDrawable(false);
+    offset_ = 0;
+    idle_alpha_ = 0;
+    active_alpha_ = 0;
+    rotation_ = 0;
+    state_ = STATE_IDLE;
+  }
+
+  void ApplyToLayers(const gfx::SizeF& size, cc::Layer* parent) {
+    if (IsFinished())
+      return;
+
+    UpdateLayer(idle_layer_.get(),
+                parent,
+                resource_manager_->GetUIResourceId(kIdleResourceType),
+                size,
+                offset_,
+                idle_alpha_,
+                rotation_);
+    UpdateLayer(active_layer_.get(),
+                parent,
+                resource_manager_->GetUIResourceId(kActiveResourceType),
+                size,
+                offset_,
+                active_alpha_,
+                rotation_);
+  }
+
+  bool IsFinished() const { return state_ == STATE_IDLE; }
+
+ private:
+  enum State {
+    STATE_IDLE = 0,
+    STATE_PULL,
+    STATE_ACTIVATED,
+    STATE_ACTIVATED_RECEDE,
+    STATE_RECEDE
+  };
+
+  void Detach() {
+    idle_layer_->RemoveFromParent();
+    active_layer_->RemoveFromParent();
+  }
+
+  ui::SystemUIResourceManager* const resource_manager_;
+
+  scoped_refptr<cc::UIResourceLayer> idle_layer_;
+  scoped_refptr<cc::UIResourceLayer> active_layer_;
+
+  float idle_alpha_;
+  float active_alpha_;
+  float offset_;
+  float rotation_;
+
+  float idle_alpha_start_;
+  float idle_alpha_finish_;
+  float active_alpha_start_;
+  float active_alpha_finish_;
+  float offset_start_;
+  float offset_finish_;
+  float rotation_start_;
+  float rotation_finish_;
+
+  base::TimeTicks start_time_;
+  base::TimeTicks activated_start_time_;
+  base::TimeDelta duration_;
+
+  State state_;
+};
+
+OverscrollRefresh::OverscrollRefresh(
+    ui::SystemUIResourceManager* resource_manager,
+    OverscrollRefreshClient* client)
+    : client_(client),
+      scroll_consumption_state_(DISABLED),
+      effect_(new Effect(resource_manager)) {
+  DCHECK(client);
+}
+
+OverscrollRefresh::~OverscrollRefresh() {
+}
+
+void OverscrollRefresh::Reset() {
+  scroll_consumption_state_ = DISABLED;
+  effect_->Finish();
+}
+
+void OverscrollRefresh::OnScrollBegin() {
+  bool allow_activation = false;
+  Release(allow_activation);
+  if (!scroll_offset_.y())
+    scroll_consumption_state_ = PENDING_SCROLL_UPDATE_ACK;
+}
+
+void OverscrollRefresh::OnScrollUpdateAck(bool consumed) {
+  // Intentionally skip the first scroll update to avoid issues
+  if (scroll_consumption_state_ == PENDING_SCROLL_UPDATE_ACK)
+    scroll_consumption_state_ = consumed ? DISABLED : ENABLED;
+}
+
+void OverscrollRefresh::OnScrollEnd(const gfx::Vector2dF& scroll_velocity) {
+  bool allow_activation = scroll_velocity.y() > -500;

[Ted C, 2014/10/31 23:52:05]

where does -500 come from?  should it be a constant?

[jdduke (slow), 2014/11/06 00:10:37]

I'll pull it out as a constant, it was from trial and error.

+  Release(allow_activation);
+}
+
+bool OverscrollRefresh::WillHandleScrollUpdate(
+    const gfx::Vector2dF& scroll_delta) {
+  if (!viewport_size_.height())
+    return false;
+
+  if (scroll_consumption_state_ == ENABLED) {
+    float normalized_delta = scroll_delta.y() / viewport_size_.height();
+    effect_->Pull(normalized_delta);
+    return true;
+  }
+
+  if (scroll_consumption_state_ == PENDING_SCROLL_UPDATE_ACK &&
+      scroll_delta.y() < 0) {

[aelias_OOO_until_Jul13, 2014/10/30 03:53:22]

I'm having trouble following what this is for, could you add a comment?

[jdduke (slow), 2014/11/06 00:10:37]

Done.

+    scroll_consumption_state_ = DISABLED;
+  }
+
+  return false;
+}
+
+bool OverscrollRefresh::Animate(base::TimeTicks current_time,
+                                cc::Layer* parent_layer) {
+  DCHECK(parent_layer);
+  if (effect_->IsFinished())
+    return false;
+
+  bool is_triggered_refresh_active = client_->IsTriggeredRefreshActive();
+  if (effect_->Update(current_time, is_triggered_refresh_active))
+    effect_->ApplyToLayers(viewport_size_, parent_layer);
+
+  return !effect_->IsFinished();
+}
+
+bool OverscrollRefresh::IsActive() const {
+  return scroll_consumption_state_ == ENABLED || !effect_->IsFinished();
+}
+
+bool OverscrollRefresh::IsPendingScrollUpdateAck() const {
+  return scroll_consumption_state_ == PENDING_SCROLL_UPDATE_ACK;
+}
+
+void OverscrollRefresh::UpdateDisplay(
+    const gfx::SizeF& viewport_size,
+    const gfx::Vector2dF& content_scroll_offset) {
+  viewport_size_ = viewport_size;
+  scroll_offset_ = content_scroll_offset;
+}
+
+void OverscrollRefresh::Release(bool allow_activation) {
+  if (scroll_consumption_state_ == ENABLED) {
+    if (effect_->Release(base::TimeTicks::Now(), allow_activation))
+      client_->TriggerRefresh();
+  }
+  scroll_consumption_state_ = DISABLED;
+}
+
+}  // namespace content