ash/touch/touch_hud_debug.cc

   1 // Copyright 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 "ash/touch/touch_hud_debug.h"
   6
   7 #include "ash/display/display_manager.h"
   8 #include "ash/root_window_controller.h"
   9 #include "ash/shell.h"
  10 #include "base/json/json_string_value_serializer.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "third_party/skia/include/core/SkPath.h"
  15 #include "ui/aura/root_window.h"
  16 #include "ui/events/event.h"
  17 #include "ui/gfx/animation/animation_delegate.h"
  18 #include "ui/gfx/canvas.h"
  19 #include "ui/gfx/display.h"
  20 #include "ui/gfx/size.h"
  21 #include "ui/gfx/transform.h"
  22 #include "ui/views/controls/label.h"
  23 #include "ui/views/layout/box_layout.h"
  24 #include "ui/views/widget/widget.h"
  25
  26 #if defined(USE_X11)
  27 #include <X11/extensions/XInput2.h>
  28 #include <X11/Xlib.h>
  29
  30 #include "ui/events/x/device_data_manager.h"
  31 #endif
  32
  33 namespace ash {
  34 namespace internal {
  35
  36 const int kPointRadius = 20;
  37 const SkColor kColors[] = {
  38   SK_ColorYELLOW,
  39   SK_ColorGREEN,
  40   SK_ColorRED,
  41   SK_ColorBLUE,
  42   SK_ColorGRAY,
  43   SK_ColorMAGENTA,
  44   SK_ColorCYAN,
  45   SK_ColorWHITE,
  46   SK_ColorBLACK,
  47   SkColorSetRGB(0xFF, 0x8C, 0x00),
  48   SkColorSetRGB(0x8B, 0x45, 0x13),
  49   SkColorSetRGB(0xFF, 0xDE, 0xAD),
  50 };
  51 const int kAlpha = 0x60;
  52 const int kMaxPaths = arraysize(kColors);
  53 const int kReducedScale = 10;
  54
  55 const char* GetTouchEventLabel(ui::EventType type) {
  56   switch (type) {
  57     case ui::ET_UNKNOWN:
  58       return " ";
  59     case ui::ET_TOUCH_PRESSED:
  60       return "P";
  61     case ui::ET_TOUCH_MOVED:
  62       return "M";
  63     case ui::ET_TOUCH_RELEASED:
  64       return "R";
  65     case ui::ET_TOUCH_CANCELLED:
  66       return "C";
  67     default:
  68       break;
  69   }
  70   return "?";
  71 }
  72
  73 int GetTrackingId(const ui::TouchEvent& event) {
  74   if (!event.HasNativeEvent())
  75     return 0;
  76 #if defined(USE_XI2_MT)
  77   ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
  78   double tracking_id;
  79   if (manager->GetEventData(*event.native_event(),
  80                             ui::DeviceDataManager::DT_TOUCH_TRACKING_ID,
  81                             &tracking_id)) {
  82     return static_cast<int>(tracking_id);
  83   }
  84 #endif
  85   return 0;
  86 }
  87
  88 int GetSourceDeviceId(const ui::TouchEvent& event) {
  89   if (!event.HasNativeEvent())
  90     return 0;
  91 #if defined(USE_X11)
  92   XEvent* xev = event.native_event();
  93   return static_cast<XIDeviceEvent*>(xev->xcookie.data)->sourceid;
  94 #endif
  95   return 0;
  96 }
  97
  98 // A TouchPointLog represents a single touch-event of a touch point.
  99 struct TouchPointLog {
 100  public:
 101   explicit TouchPointLog(const ui::TouchEvent& touch)
 102       : id(touch.touch_id()),
 103         type(touch.type()),
 104         location(touch.root_location()),
 105         timestamp(touch.time_stamp().InMillisecondsF()),
 106         radius_x(touch.radius_x()),
 107         radius_y(touch.radius_y()),
 108         pressure(touch.force()),
 109         tracking_id(GetTrackingId(touch)),
 110         source_device(GetSourceDeviceId(touch)) {
 111   }
 112
 113   // Populates a dictionary value with all the information about the touch
 114   // point.
 115   scoped_ptr<DictionaryValue> GetAsDictionary() const {
 116     scoped_ptr<DictionaryValue> value(new DictionaryValue());
 117
 118     value->SetInteger("id", id);
 119     value->SetString("type", std::string(GetTouchEventLabel(type)));
 120     value->SetString("location", location.ToString());
 121     value->SetDouble("timestamp", timestamp);
 122     value->SetDouble("radius_x", radius_x);
 123     value->SetDouble("radius_y", radius_y);
 124     value->SetDouble("pressure", pressure);
 125     value->SetInteger("tracking_id", tracking_id);
 126     value->SetInteger("source_device", source_device);
 127
 128     return value.Pass();
 129   }
 130
 131   int id;
 132   ui::EventType type;
 133   gfx::Point location;
 134   double timestamp;
 135   float radius_x;
 136   float radius_y;
 137   float pressure;
 138   int tracking_id;
 139   int source_device;
 140 };
 141
 142 // A TouchTrace keeps track of all the touch events of a single touch point
 143 // (starting from a touch-press and ending at a touch-release or touch-cancel).
 144 class TouchTrace {
 145  public:
 146   typedef std::vector<TouchPointLog>::iterator iterator;
 147   typedef std::vector<TouchPointLog>::const_iterator const_iterator;
 148   typedef std::vector<TouchPointLog>::reverse_iterator reverse_iterator;
 149   typedef std::vector<TouchPointLog>::const_reverse_iterator
 150       const_reverse_iterator;
 151
 152   TouchTrace() {
 153   }
 154
 155   void AddTouchPoint(const ui::TouchEvent& touch) {
 156     log_.push_back(TouchPointLog(touch));
 157   }
 158
 159   const std::vector<TouchPointLog>& log() const { return log_; }
 160
 161   bool active() const {
 162     return !log_.empty() && log_.back().type != ui::ET_TOUCH_RELEASED &&
 163         log_.back().type != ui::ET_TOUCH_CANCELLED;
 164   }
 165
 166   // Returns a list containing data from all events for the touch point.
 167   scoped_ptr<ListValue> GetAsList() const {
 168     scoped_ptr<ListValue> list(new ListValue());
 169     for (const_iterator i = log_.begin(); i != log_.end(); ++i)
 170       list->Append((*i).GetAsDictionary().release());
 171     return list.Pass();
 172   }
 173
 174   void Reset() {
 175     log_.clear();
 176   }
 177
 178  private:
 179   std::vector<TouchPointLog> log_;
 180
 181   DISALLOW_COPY_AND_ASSIGN(TouchTrace);
 182 };
 183
 184 // A TouchLog keeps track of all touch events of all touch points.
 185 class TouchLog {
 186  public:
 187   TouchLog() : next_trace_index_(0) {
 188   }
 189
 190   void AddTouchPoint(const ui::TouchEvent& touch) {
 191     if (touch.type() == ui::ET_TOUCH_PRESSED)
 192       StartTrace(touch);
 193     AddToTrace(touch);
 194   }
 195
 196   void Reset() {
 197     next_trace_index_ = 0;
 198     for (int i = 0; i < kMaxPaths; ++i)
 199       traces_[i].Reset();
 200   }
 201
 202   scoped_ptr<ListValue> GetAsList() const {
 203     scoped_ptr<ListValue> list(new ListValue());
 204     for (int i = 0; i < kMaxPaths; ++i) {
 205       if (!traces_[i].log().empty())
 206         list->Append(traces_[i].GetAsList().release());
 207     }
 208     return list.Pass();
 209   }
 210
 211   int GetTraceIndex(int touch_id) const {
 212     return touch_id_to_trace_index_.at(touch_id);
 213   }
 214
 215   const TouchTrace* traces() const {
 216     return traces_;
 217   }
 218
 219  private:
 220   void StartTrace(const ui::TouchEvent& touch) {
 221     // Find the first inactive spot; otherwise, overwrite the one
 222     // |next_trace_index_| is pointing to.
 223     int old_trace_index = next_trace_index_;
 224     do {
 225       if (!traces_[next_trace_index_].active())
 226         break;
 227       next_trace_index_ = (next_trace_index_ + 1) % kMaxPaths;
 228     } while (next_trace_index_ != old_trace_index);
 229     int touch_id = touch.touch_id();
 230     traces_[next_trace_index_].Reset();
 231     touch_id_to_trace_index_[touch_id] = next_trace_index_;
 232     next_trace_index_ = (next_trace_index_ + 1) % kMaxPaths;
 233   }
 234
 235   void AddToTrace(const ui::TouchEvent& touch) {
 236     int touch_id = touch.touch_id();
 237     int trace_index = touch_id_to_trace_index_[touch_id];
 238     traces_[trace_index].AddTouchPoint(touch);
 239   }
 240
 241   TouchTrace traces_[kMaxPaths];
 242   int next_trace_index_;
 243
 244   std::map<int, int> touch_id_to_trace_index_;
 245
 246   DISALLOW_COPY_AND_ASSIGN(TouchLog);
 247 };
 248
 249 // TouchHudCanvas draws touch traces in |FULLSCREEN| and |REDUCED_SCALE| modes.
 250 class TouchHudCanvas : public views::View {
 251  public:
 252   explicit TouchHudCanvas(const TouchLog& touch_log)
 253       : touch_log_(touch_log),
 254         scale_(1) {
 255     SetPaintToLayer(true);
 256     SetFillsBoundsOpaquely(false);
 257
 258     paint_.setStyle(SkPaint::kFill_Style);
 259   }
 260
 261   virtual ~TouchHudCanvas() {}
 262
 263   void SetScale(int scale) {
 264     if (scale_ == scale)
 265       return;
 266     scale_ = scale;
 267     gfx::Transform transform;
 268     transform.Scale(1. / scale_, 1. / scale_);
 269     layer()->SetTransform(transform);
 270   }
 271
 272   int scale() const { return scale_; }
 273
 274   void TouchPointAdded(int touch_id) {
 275     int trace_index = touch_log_.GetTraceIndex(touch_id);
 276     const TouchTrace& trace = touch_log_.traces()[trace_index];
 277     const TouchPointLog& point = trace.log().back();
 278     if (point.type == ui::ET_TOUCH_PRESSED)
 279       StartedTrace(trace_index);
 280     if (point.type != ui::ET_TOUCH_CANCELLED)
 281       AddedPointToTrace(trace_index);
 282   }
 283
 284   void Clear() {
 285     for (int i = 0; i < kMaxPaths; ++i)
 286       paths_[i].reset();
 287
 288     SchedulePaint();
 289   }
 290
 291  private:
 292   void StartedTrace(int trace_index) {
 293     paths_[trace_index].reset();
 294     colors_[trace_index] = SkColorSetA(kColors[trace_index], kAlpha);
 295   }
 296
 297   void AddedPointToTrace(int trace_index) {
 298     const TouchTrace& trace = touch_log_.traces()[trace_index];
 299     const TouchPointLog& point = trace.log().back();
 300     const gfx::Point& location = point.location;
 301     SkScalar x = SkIntToScalar(location.x());
 302     SkScalar y = SkIntToScalar(location.y());
 303     SkPoint last;
 304     if (!paths_[trace_index].getLastPt(&last) || x != last.x() ||
 305         y != last.y()) {
 306       paths_[trace_index].addCircle(x, y, SkIntToScalar(kPointRadius));
 307       SchedulePaint();
 308     }
 309   }
 310
 311   // Overridden from views::View.
 312   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
 313     for (int i = 0; i < kMaxPaths; ++i) {
 314       if (paths_[i].countPoints() == 0)
 315         continue;
 316       paint_.setColor(colors_[i]);
 317       canvas->DrawPath(paths_[i], paint_);
 318     }
 319   }
 320
 321   SkPaint paint_;
 322
 323   const TouchLog& touch_log_;
 324   SkPath paths_[kMaxPaths];
 325   SkColor colors_[kMaxPaths];
 326
 327   int scale_;
 328
 329   DISALLOW_COPY_AND_ASSIGN(TouchHudCanvas);
 330 };
 331
 332 TouchHudDebug::TouchHudDebug(aura::Window* initial_root)
 333     : TouchObserverHUD(initial_root),
 334       mode_(FULLSCREEN),
 335       touch_log_(new TouchLog()),
 336       canvas_(NULL),
 337       label_container_(NULL) {
 338   const gfx::Display& display =
 339       Shell::GetInstance()->display_manager()->GetDisplayForId(display_id());
 340
 341   views::View* content = widget()->GetContentsView();
 342
 343   canvas_ = new TouchHudCanvas(*touch_log_);
 344   content->AddChildView(canvas_);
 345
 346   const gfx::Size& display_size = display.size();
 347   canvas_->SetSize(display_size);
 348
 349   label_container_ = new views::View;
 350   label_container_->SetLayoutManager(new views::BoxLayout(
 351       views::BoxLayout::kVertical, 0, 0, 0));
 352
 353   for (int i = 0; i < kMaxTouchPoints; ++i) {
 354     touch_labels_[i] = new views::Label;
 355     touch_labels_[i]->SetBackgroundColor(SkColorSetARGB(0, 255, 255, 255));
 356     touch_labels_[i]->SetShadowColors(SK_ColorWHITE,
 357                                       SK_ColorWHITE);
 358     touch_labels_[i]->SetShadowOffset(1, 1);
 359     label_container_->AddChildView(touch_labels_[i]);
 360   }
 361   label_container_->SetX(0);
 362   label_container_->SetY(display_size.height() / kReducedScale);
 363   label_container_->SetSize(label_container_->GetPreferredSize());
 364   label_container_->SetVisible(false);
 365   content->AddChildView(label_container_);
 366 }
 367
 368 TouchHudDebug::~TouchHudDebug() {
 369 }
 370
 371 // static
 372 scoped_ptr<DictionaryValue> TouchHudDebug::GetAllAsDictionary() {
 373   scoped_ptr<DictionaryValue> value(new DictionaryValue());
 374   aura::Window::Windows roots = Shell::GetInstance()->GetAllRootWindows();
 375   for (aura::Window::Windows::iterator iter = roots.begin();
 376       iter != roots.end(); ++iter) {
 377     internal::RootWindowController* controller = GetRootWindowController(*iter);
 378     internal::TouchHudDebug* hud = controller->touch_hud_debug();
 379     if (hud) {
 380       scoped_ptr<ListValue> list = hud->GetLogAsList();
 381       if (!list->empty())
 382         value->Set(base::Int64ToString(hud->display_id()), list.release());
 383     }
 384   }
 385   return value.Pass();
 386 }
 387
 388 void TouchHudDebug::ChangeToNextMode() {
 389   switch (mode_) {
 390     case FULLSCREEN:
 391       SetMode(REDUCED_SCALE);
 392       break;
 393     case REDUCED_SCALE:
 394       SetMode(INVISIBLE);
 395       break;
 396     case INVISIBLE:
 397       SetMode(FULLSCREEN);
 398       break;
 399   }
 400 }
 401
 402 scoped_ptr<ListValue> TouchHudDebug::GetLogAsList() const {
 403   return touch_log_->GetAsList();
 404 }
 405
 406 void TouchHudDebug::Clear() {
 407   if (widget()->IsVisible()) {
 408     canvas_->Clear();
 409     for (int i = 0; i < kMaxTouchPoints; ++i)
 410       touch_labels_[i]->SetText(string16());
 411     label_container_->SetSize(label_container_->GetPreferredSize());
 412   }
 413 }
 414
 415 void TouchHudDebug::SetMode(Mode mode) {
 416   if (mode_ == mode)
 417     return;
 418   mode_ = mode;
 419   switch (mode) {
 420     case FULLSCREEN:
 421       label_container_->SetVisible(false);
 422       canvas_->SetVisible(true);
 423       canvas_->SetScale(1);
 424       canvas_->SchedulePaint();
 425       widget()->Show();
 426       break;
 427     case REDUCED_SCALE:
 428       label_container_->SetVisible(true);
 429       canvas_->SetVisible(true);
 430       canvas_->SetScale(kReducedScale);
 431       canvas_->SchedulePaint();
 432       widget()->Show();
 433       break;
 434     case INVISIBLE:
 435       widget()->Hide();
 436       break;
 437   }
 438 }
 439
 440 void TouchHudDebug::UpdateTouchPointLabel(int index) {
 441   int trace_index = touch_log_->GetTraceIndex(index);
 442   const TouchTrace& trace = touch_log_->traces()[trace_index];
 443   TouchTrace::const_reverse_iterator point = trace.log().rbegin();
 444   ui::EventType touch_status = point->type;
 445   float touch_radius = std::max(point->radius_x, point->radius_y);
 446   while (point != trace.log().rend() && point->type == ui::ET_TOUCH_CANCELLED)
 447     point++;
 448   DCHECK(point != trace.log().rend());
 449   gfx::Point touch_position = point->location;
 450
 451   std::string string = base::StringPrintf("%2d: %s %s (%.4f)",
 452                                           index,
 453                                           GetTouchEventLabel(touch_status),
 454                                           touch_position.ToString().c_str(),
 455                                           touch_radius);
 456   touch_labels_[index]->SetText(UTF8ToUTF16(string));
 457 }
 458
 459 void TouchHudDebug::OnTouchEvent(ui::TouchEvent* event) {
 460   if (event->touch_id() >= kMaxTouchPoints)
 461     return;
 462
 463   touch_log_->AddTouchPoint(*event);
 464   canvas_->TouchPointAdded(event->touch_id());
 465   UpdateTouchPointLabel(event->touch_id());
 466   label_container_->SetSize(label_container_->GetPreferredSize());
 467 }
 468
 469 void TouchHudDebug::OnDisplayBoundsChanged(const gfx::Display& display) {
 470   TouchObserverHUD::OnDisplayBoundsChanged(display);
 471
 472   if (display.id() != display_id())
 473     return;
 474   const gfx::Size& size = display.size();
 475   canvas_->SetSize(size);
 476   label_container_->SetY(size.height() / kReducedScale);
 477 }
 478
 479 void TouchHudDebug::SetHudForRootWindowController(
 480     RootWindowController* controller) {
 481   controller->set_touch_hud_debug(this);
 482 }
 483
 484 void TouchHudDebug::UnsetHudForRootWindowController(
 485     RootWindowController* controller) {
 486   controller->set_touch_hud_debug(NULL);
 487 }
 488
 489 }  // namespace internal
 490 }  // namespace ash