remoting/client/ui/fling_tracker.cc

// Copyright 2017 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 "remoting/client/ui/fling_tracker.h"

#include <cmath>

namespace remoting {

namespace {

const float kSecToMs = 0.001f;

// TODO(yuweih): May need to tweak these numbers to get better smoothness.

// Stop flinging if the speed drops below this. This is a small speed to make
// sure the animation stops smoothly.
const float kMinTrackSpeed = 0.01f;

// The minimum displacement needed to trigger the fling animation. This is to
// prevent unintentional fling with low velocity.
const float kMinDisplacement = 20.f;

float GetDisplacement(float time_constant,
                      float initial_speed_rate,
                      float time_elapsed) {
  // x = T * v0 * (1 - e^(-t / T))
  // This comes from a solution to the linear drag equation F=-kv
  float exp_factor = -std::expm1(-time_elapsed / time_constant);
  return time_constant * initial_speed_rate * exp_factor;
}

// Returns the time needed for the object to get to the stable state where the
// speed drops below kMinTrackSpeed.
float GetDuration(float time_constant, float initial_speed_rate) {
  // t = -T * ln(kMinTrackSpeed / v0)
  // Solution of v(t) = kMinTrackSpeed
  return -time_constant * std::log(kMinTrackSpeed / initial_speed_rate);
}

}  // namespace

FlingTracker::FlingTracker(float time_constant)
    : time_constant_(time_constant) {}

FlingTracker::~FlingTracker() = default;

void FlingTracker::StartFling(float velocity_x, float velocity_y) {
  // Convert to pixel/ms
  velocity_x *= kSecToMs;
  velocity_y *= kSecToMs;

  initial_speed_rate_ =
      std::sqrt(velocity_x * velocity_x + velocity_y * velocity_y);

  if (initial_speed_rate_ < kMinTrackSpeed) {
    StopFling();
    return;
  }

  fling_duration_ = GetDuration(time_constant_, initial_speed_rate_);

  float final_displacement =
      GetDisplacement(time_constant_, initial_speed_rate_, fling_duration_);
  if (final_displacement < kMinDisplacement) {
    StopFling();
    return;
  }

  velocity_ratio_x_ = velocity_x / initial_speed_rate_;
  velocity_ratio_y_ = velocity_y / initial_speed_rate_;

  previous_position_x_ = 0;
  previous_position_y_ = 0;
}

void FlingTracker::StopFling() {
  initial_speed_rate_ = 0.f;
}

bool FlingTracker::IsFlingInProgress() const {
  return initial_speed_rate_ > 0;
}

bool FlingTracker::TrackMovement(base::TimeDelta time_elapsed,
                                 float* dx,
                                 float* dy) {
  if (!IsFlingInProgress()) {
    return false;
  }

  float time_elapsed_ms = time_elapsed.InMilliseconds();

  if (time_elapsed_ms > fling_duration_) {
    StopFling();
    return false;
  }

  float displacement =
      GetDisplacement(time_constant_, initial_speed_rate_, time_elapsed_ms);

  float position_x = displacement * velocity_ratio_x_;
  float position_y = displacement * velocity_ratio_y_;

  *dx = position_x - previous_position_x_;
  *dy = position_y - previous_position_y_;

  previous_position_x_ = position_x;
  previous_position_y_ = position_y;

  return true;
}

}  // namespace remoting