touch_keyboard/fakekeyboard.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2016 The Chromium OS 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 "touch_keyboard/fakekeyboard.h"

 namespace touch_keyboard {

 // This sets how long (in ms) to delay a key down event before sending it.  More
 // delay causes a visible lag when typing and a shorter delay means the system
 // has less time to confirm keypresses and may increase the error rate.
 constexpr int kEventDelayMS = 50;

 // These dummy values are used to track events.
 constexpr bool kKeyDownEvent = true;
 constexpr bool kKeyUpEvent = false;
 constexpr int kNoKey = -1;
 constexpr int kOldTID = -999;

 // Below are the dimensions of the Pbody touch keyboard and the key locations.
 // TODO(charliemooney): These are hardcoded constants used in SetUpLayout and
 // should be removed once that function is upgraded to load a keymap from disk.
 constexpr int kInputWidth = 2702;
 constexpr int kInputHeight = 1715;
 constexpr int kWidthMM = 266;
 constexpr int kHeightMM = 168;
 constexpr float kWidthPitch = kInputWidth / static_cast<float>(kWidthMM);
 constexpr float kHeightPitch = kInputHeight / static_cast<float>(kHeightMM);
 constexpr float kKeyWidthMM = 18.5;
 constexpr float kKeyHeightMM = 19.0;
 constexpr float kKeyWidth = kKeyWidthMM * kWidthPitch;
 constexpr float kKeyHeight = kKeyHeightMM * kHeightPitch;
 constexpr int kBottomRowYmin = 630;
 constexpr float kFnKeyWidth = 22.0 * kWidthPitch;
 constexpr float kFnKeyHeight = 12.0 * kHeightPitch;
 constexpr float kArrowKeyHeight = kKeyHeight / 2.0;
 constexpr float kWideArrowKeyWidth = 23.0 * kWidthPitch;
 constexpr float kLeftCtrlWidth = 42.0 * kWidthPitch;
 constexpr float kLeftAltWidth = 37.0 * kWidthPitch;
 constexpr float kSpaceWidth = 93.0 * kWidthPitch;
 constexpr float kShiftWidth = 41.0 * kWidthPitch;
 constexpr float kSearchWidth = 32.0 * kWidthPitch;
 constexpr float kEnterWidth = 32.0 * kWidthPitch;
 constexpr float kTabWidth = 27.0 * kWidthPitch;
 constexpr float kBackspaceWidth = 27.0 * kWidthPitch;

 constexpr int kMinTapPressure = 50;
 constexpr int kMaxTapPressure = 110;

 FakeKeyboard::FakeKeyboard() : ff_manager_(kInputWidth) {
   SetUpLayout();
 }

 void FakeKeyboard::SetUpLayout() {
   // This function sets up the key code and their locations.
   // TODO(charliemooney): Currently this has a layout hard-coded into it.
   //     Obviously, that's a bad idea.  This needs to be updated to load
   //     a layout from disk somewhere once things have stabilized a little.
   unsigned int i;
   int row1[] = {KEY_Z, KEY_X, KEY_C, KEY_V, KEY_B, KEY_N, KEY_M, KEY_COMMA,
                 KEY_DOT, KEY_SLASH};
   int row2[] = {KEY_A, KEY_S, KEY_D, KEY_F, KEY_G, KEY_H, KEY_J, KEY_K, KEY_L,
                 KEY_SEMICOLON, KEY_APOSTROPHE};
   int row3[] = {KEY_Q, KEY_W, KEY_E, KEY_R, KEY_T, KEY_Y, KEY_U, KEY_I,
                 KEY_O, KEY_P, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH};
   int row4[] = {KEY_GRAVE, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7,
                 KEY_8, KEY_9, KEY_0, KEY_MINUS, KEY_EQUAL};
   int rowfn[] = {KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6,
                  KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F13};


   int bottom_row_ymin = kBottomRowYmin;
   layout_.push_back(Key(KEY_LEFTCTRL,
                         0,
                         kLeftCtrlWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kKeyHeight));
   layout_.push_back(Key(KEY_LEFTALT,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kLeftAltWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kKeyHeight));
   layout_.push_back(Key(KEY_SPACE,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kSpaceWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kKeyHeight));
   layout_.push_back(Key(KEY_RIGHTALT,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kKeyWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kKeyHeight));
   layout_.push_back(Key(KEY_RIGHTCTRL,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kKeyWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kKeyHeight));
   layout_.push_back(Key(KEY_LEFT,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kKeyWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kArrowKeyHeight));
   layout_.push_back(Key(KEY_DOWN,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kWideArrowKeyWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kArrowKeyHeight));
   layout_.push_back(Key(KEY_UP,
                         layout_.back().xmin_,
                         layout_.back().xmax_,
                         bottom_row_ymin + kArrowKeyHeight,
                         bottom_row_ymin + kKeyWidth));
   layout_.push_back(Key(KEY_RIGHT,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kKeyWidth,
                         bottom_row_ymin,
                         bottom_row_ymin + kArrowKeyHeight));


   int row1_ymin = bottom_row_ymin + kKeyHeight;
   layout_.push_back(Key(KEY_LEFTSHIFT,
                         0,
                         kShiftWidth,
                         row1_ymin,
                         row1_ymin + kKeyHeight));
   for (i = 0; i < arraysize(row1); i++) {
     layout_.push_back(Key(row1[i],
                           kShiftWidth + i * kKeyWidth,
                           kShiftWidth + i * kKeyWidth + kKeyWidth,
                           row1_ymin,
                           row1_ymin + kKeyHeight));
   }
   layout_.push_back(Key(KEY_RIGHTSHIFT,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kShiftWidth,
                         row1_ymin,
                         row1_ymin + kKeyHeight));

   int row2_ymin = row1_ymin + kKeyHeight;
   layout_.push_back(Key(KEY_LEFTMETA,
                         0,
                         kSearchWidth,
                         row2_ymin,
                         row2_ymin + kKeyHeight));
   for (i = 0; i < arraysize(row2); i++) {
     layout_.push_back(Key(row2[i],
                           kSearchWidth + i * kKeyWidth,
                           kSearchWidth + i * kKeyWidth + kKeyWidth,
                           row2_ymin,
                           row2_ymin + kKeyHeight));
   }
   layout_.push_back(Key(KEY_ENTER,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kEnterWidth,
                         row2_ymin,
                         row2_ymin + kKeyHeight));

   int row3_ymin = row2_ymin + kKeyHeight;
   layout_.push_back(Key(KEY_TAB,
                         0,
                         kTabWidth,
                         row3_ymin,
                         row3_ymin + kKeyHeight));
   for (i = 0; i < arraysize(row3); i++) {
     layout_.push_back(Key(row3[i],
                           kTabWidth + i * kKeyWidth,
                           kTabWidth + i * kKeyWidth + kKeyWidth,
                           row3_ymin,
                           row3_ymin + kKeyHeight));
   }

   int row4_ymin = row3_ymin + kKeyHeight;
   for (i = 0; i < arraysize(row4); i++) {
     layout_.push_back(Key(row4[i],
                           i * kKeyWidth,
                           i * kKeyWidth + kKeyWidth,
                           row4_ymin,
                           row4_ymin + kKeyHeight));
   }
   layout_.push_back(Key(KEY_BACKSPACE,
                         layout_.back().xmax_,
                         layout_.back().xmax_ + kBackspaceWidth,
                         row4_ymin,
                         row4_ymin + kKeyHeight));

   int rowfn_ymin = row4_ymin + kKeyHeight;
   for (i = 0; i < arraysize(rowfn); i++) {
     layout_.push_back(Key(rowfn[i],
                           i * kFnKeyWidth,
                           i * kFnKeyWidth + kFnKeyWidth,
                           rowfn_ymin,
                           rowfn_ymin + kFnKeyHeight));
   }
 }


 void FakeKeyboard::EnableKeyboardEvents() const {
   // Enable key events in general for output.
   EnableEventType(EV_KEY);
   // Enable each specific key code found in the layout.
   for (unsigned int i = 0; i < layout_.size(); i++) {
     EnableKeyEvent(layout_[i].event_code_);
   }
 }

 struct timespec FakeKeyboard::AddMsToTimespec(struct timespec const& orig,
                                               int additional_ms) {
   struct timespec extended = orig;
   extended.tv_nsec += additional_ms * 1e6;
   while (extended.tv_nsec >= 1e9) {
     extended.tv_nsec -= 1e9;
     extended.tv_sec += 1;
   }
   return extended;
 }

 bool FakeKeyboard::TimespecIsLater(struct timespec const& t1,
                                     struct timespec const& t2) {
   return ((t1.tv_sec > t2.tv_sec) ||
           (t1.tv_sec == t2.tv_sec && t1.tv_nsec > t2.tv_nsec));
 }

 int FakeKeyboard::GenerateEventForArrivingFinger(
     struct timespec now,
     struct mtstatemachine::MtFinger const &finger, int tid) {
   for (unsigned int key_num = 0; key_num < layout_.size(); key_num++) {
     if (layout_[key_num].Contains(finger.x, finger.y)) {
       Event ev(layout_[key_num].event_code_, kKeyDownEvent,
                AddMsToTimespec(now, kEventDelayMS), tid);
       EnqueueEvent(ev);
       return key_num;
     }
   }
   return kNoKey;
 }

 void FakeKeyboard::HandleLeavingFinger(int tid, FingerData finger,
                                        timespec now) {
   bool up_event_guaranteed = false, down_event_guaranteed = false;

   // If the finger has already been marked dead for some reason, ignore it.
   if (finger.rejection_status_ != RejectionStatus::kNotRejectedYet) {
     return;
   }

   // If there is an outstanding down event for this finger and mark it
   // guaranteed.
   if (!finger.down_sent_) {
     std::list<Event>::iterator it = pending_events_.begin();
     while (it != pending_events_.end()) {
       if (it->tid_ == tid) {
         it->is_guaranteed_ = true;
         down_event_guaranteed |= it->is_down_;
         up_event_guaranteed |= !it->is_down_;
         break;
       }
       it++;
     }
   }

   // If we're here we either have already sent the key_down event for this
   // finger, or have just marked in guaranteed.  Either way we have to enqueue
   // a guaranteed up event now if there isn't one already.
   if (!up_event_guaranteed) {
     EnqueueKeyUpEvent(layout_[finger.starting_key_number_].event_code_, now);
   }
 }

 void FakeKeyboard::EnqueueKeyUpEvent(int ev_code, timespec now) {
   Event up_event(ev_code, kKeyUpEvent,
                  AddMsToTimespec(now, kEventDelayMS), kOldTID);
   up_event.is_guaranteed_ = true;
   EnqueueEvent(up_event);
 }

 bool FakeKeyboard::StillOnFirstKey(
     struct mtstatemachine::MtFinger const & finger,
     FingerData const & data) const {
   // If this finger didn't start on a key, then automatically return false.
   if (data.starting_key_number_ == kNoKey) {
     return false;
   }

   // Otherwise, see if it's still contained in that starting key.
   return layout_.at(data.starting_key_number_).Contains(finger.x, finger.y);
 }

 void FakeKeyboard::RejectFinger(int tid, RejectionStatus reason) {
   // First, mark the finger's FingerData as rejected.
   finger_data_[tid].rejection_status_ = reason;

   // Next, scan through the pending events and delete any for that finger.
   std::list<Event>::iterator it = pending_events_.begin();
   while (it != pending_events_.end()) {
     auto current = it++;
     if (current->tid_ == tid) {
       pending_events_.erase(current);
     }
   }
 }

 void FakeKeyboard::ProcessIncomingSnapshot(
     struct timespec now,
     std::unordered_map<int, struct mtstatemachine::MtFinger> const &snapshot) {
   // First we go through all the touches reported by the touchscreen in the most
   // recent snapshot.
   for (auto map_entry : snapshot) {
     int tid = map_entry.first;
     struct mtstatemachine::MtFinger finger = map_entry.second;

     std::unordered_map<int, FingerData>::iterator data_for_tid_it;
     data_for_tid_it = finger_data_.find(tid);
     if (data_for_tid_it == finger_data_.end()) {
       int ev_code_ = GenerateEventForArrivingFinger(now, finger, tid);

       // If this is a newly arriving finger, make a new entry for it and fill
       // out all the starting data we have.  In some cases, this may invalidate
       // a finger immediately.
       FingerData data;
       data.arrival_time_ = now;
       data.max_pressure_ = finger.p;
       data.starting_key_number_ = ev_code_;
       data.down_sent_ = false;
       data.rejection_status_ = RejectionStatus::kNotRejectedYet;

       if (ev_code_ == kNoKey) {
         data.rejection_status_ = RejectionStatus::kRejectTouchdownOffKey;
       } else {
         ff_manager_.EventTriggered(TouchKeyboardEvent::FingerDown, finger.x);
       }

       // TODO(charliemooney): Add more data here that can be used for
       // tracking fingers.
       finger_data_[tid] = data;
     } else if (data_for_tid_it->second.rejection_status_ ==
                RejectionStatus::kNotRejectedYet) {
       // If we've seen this finger before, update the data on it.
       // First, Check if the maxium pressure has changed.
       data_for_tid_it->second.max_pressure_ =
           std::max(data_for_tid_it->second.max_pressure_, finger.p);

       // Check if the finger has left the key it started on
       if (!StillOnFirstKey(finger, data_for_tid_it->second)) {
         RejectFinger(data_for_tid_it->first,
                      RejectionStatus::kRejectMovedOffKey);
         if (data_for_tid_it->second.down_sent_) {
           // Send a KeyUp event to cancel any held-down buttons.
           EnqueueKeyUpEvent(
               layout_[data_for_tid_it->second.starting_key_number_].event_code_,
               now);
         }
       }

       // TODO(charliemooney): Update the additional data here, once it's added.
     }
   }

   // Next we need to check if there are any fingers missing that we saw before
   // which would indicate a finger leaving the touchscreen.
   std::unordered_map<int, FingerData>::iterator data_it = finger_data_.begin();
   while (data_it != finger_data_.end()) {
     int tid = data_it->first;
     FingerData this_finger_data = data_it->second;
     auto input_it = snapshot.find(tid);
     if (tid != kOldTID && input_it == snapshot.end()) {
       HandleLeavingFinger(tid, this_finger_data, now);
       auto next = data_it;
       next++;
       finger_data_.erase(data_it);
       data_it = next;
     } else {
       data_it++;
     }
   }
 }

 void FakeKeyboard::EnqueueEvent(Event ev) {
   // Find the right place in the queue, maintaining the order.
   std::list<Event>::iterator it = pending_events_.begin();
   while (it != pending_events_.end()) {
     if (TimespecIsLater(it->deadline_, ev.deadline_)) {
       pending_events_.insert(it, ev);
       return;
     }
     it++;
   }

   // If we didn't find a place for it, then it must belong at the end.
   pending_events_.push_back(ev);
 }

 void FakeKeyboard::Consume() {
   while (1) {
     bool needs_syn = false;

     // Compute how long to wait for a timeout. (At most until the next pending
     // event is set to fire)
     struct timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
     int timeout_ms = -1;  // No timeout if there aren't any pending events.
     if (!pending_events_.empty()) {
       timespec deadline = pending_events_.front().deadline_;
       timeout_ms = ((deadline.tv_sec - now.tv_sec) * 1000 +
                     (deadline.tv_nsec - now.tv_nsec) / 1000000);
       timeout_ms++;  // Always add 1 more ms so as to not undershoot.
       if (timeout_ms < 0) {
         LOG(WARNING) << "Negative timeout (" << timeout_ms <<
                         ").  We missed an event somewhere!\n";
         timeout_ms = 1;
       }
     }

     // Wait for a touchscreen event or a timeout.  If there's an event from
     // the touchscreen add it to the statemachine.  Otherwise, that means it's
     // time to fire the next pending event.
     struct input_event ev;
     bool event_ready = GetNextEvent(timeout_ms, &ev);
     clock_gettime(CLOCK_MONOTONIC, &now);
     if (event_ready) {
       std::unordered_map<int, struct mtstatemachine::MtFinger> snapshot;
       if (sm_.AddEvent(ev, &snapshot)) {
         // Here we process the new snapshot, enqueing events as needed.
         ProcessIncomingSnapshot(now, snapshot);
       } else {
         // If it was a touchscreen event but *not* the end of a snapshot, then
         // just continue the loop.  This allows us to treat touchscreen events
         // as atomic events where the entire snapshot arrives at one time.
         continue;
       }
     }

     // Loop over pending events and process any that are ready to fire.
     while (!pending_events_.empty()) {
       // If the next event's deadline is still in the future, stop looking.
       Event next_event = pending_events_.front();
       if (TimespecIsLater(next_event.deadline_, now)) {
         break;
       }

       // Pop off the next pending event and process it now.
       pending_events_.pop_front();

       // Look up the FingerData associated with this event and make sure the
       // event is still valid.
       std::unordered_map<int, FingerData>::iterator it;
       it = finger_data_.find(next_event.tid_);
       if (it != finger_data_.end()) {
         // Here we check to see if this event is still valid before firing it
         // off to the OS.  Currently there is only a pressure check here, but
         // more could easily be added later.

         // This checks if the maximum pressure a finger reported is within
         // range.  An exception is made for the spacebar since it is often
         // pressed by a user's thumb, which may have unusually high pressure.
         if (it->second.max_pressure_ < kMinTapPressure ||
             (layout_[it->second.starting_key_number_].event_code_ !=
              KEY_SPACE && it->second.max_pressure_ > kMaxTapPressure)) {
           LOG(INFO) << "Tap rejected!  Pressure of " <<
                     it->second.max_pressure_ << " is out of range " <<
                     kMinTapPressure << "->" << kMaxTapPressure;
           continue;
         }
       } else {
         // The finger has already left -- that's OK as long as it is
         // "guaranteed" to fire.
         if (!next_event.is_guaranteed_) {
           LOG(ERROR) << "No finger data for event that should have some! " <<
                        "(guaranteed: " << next_event.is_guaranteed_ << ", " <<
                        "is_down: " << next_event.is_down_ << ", " <<
                        "tid: " << next_event.tid_ << ")";
         }
       }

       // Actually send the event and update the fingerdata if applicable.
       SendEvent(EV_KEY, next_event.ev_code_, next_event.is_down_ ? 1 : 0);
       needs_syn = true;
       if (next_event.is_down_) {
         std::unordered_map<int, FingerData>::iterator it;
         it = finger_data_.find(next_event.tid_);
         if (it != finger_data_.end()) {
           finger_data_[next_event.tid_].down_sent_ = true;
         }
       }
     }
     if (needs_syn) {
       // Finally, send out a SYN after all applicable events are sent.
       SendEvent(EV_SYN, SYN_REPORT, 0);
     }
   }
 }

 void FakeKeyboard::Start(std::string const &source_device_path,
                          std::string const &keyboard_device_name) {
   // Do all the set up steps.
   OpenSourceDevice(source_device_path);
   CreateUinputFD();
   EnableKeyboardEvents();
   FinalizeUinputCreation(keyboard_device_name);

   // Loop forever, comsuming the events coming in from the source device and
   // generating keystroke events when appropriate.
   Consume();
 }

 }  // namespace touch_keyboard
	// Copyright 2016 The Chromium OS 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 "touch_keyboard/fakekeyboard.h"

	namespace touch_keyboard {

	// This sets how long (in ms) to delay a key down event before sending it. More
	// delay causes a visible lag when typing and a shorter delay means the system
	// has less time to confirm keypresses and may increase the error rate.
	constexpr int kEventDelayMS = 50;

	// These dummy values are used to track events.
	constexpr bool kKeyDownEvent = true;
	constexpr bool kKeyUpEvent = false;
	constexpr int kNoKey = -1;
	constexpr int kOldTID = -999;

	// Below are the dimensions of the Pbody touch keyboard and the key locations.
	// TODO(charliemooney): These are hardcoded constants used in SetUpLayout and
	// should be removed once that function is upgraded to load a keymap from disk.
	constexpr int kInputWidth = 2702;
	constexpr int kInputHeight = 1715;
	constexpr int kWidthMM = 266;
	constexpr int kHeightMM = 168;
	constexpr float kWidthPitch = kInputWidth / static_cast<float>(kWidthMM);
	constexpr float kHeightPitch = kInputHeight / static_cast<float>(kHeightMM);
	constexpr float kKeyWidthMM = 18.5;
	constexpr float kKeyHeightMM = 19.0;
	constexpr float kKeyWidth = kKeyWidthMM * kWidthPitch;
	constexpr float kKeyHeight = kKeyHeightMM * kHeightPitch;
	constexpr int kBottomRowYmin = 630;
	constexpr float kFnKeyWidth = 22.0 * kWidthPitch;
	constexpr float kFnKeyHeight = 12.0 * kHeightPitch;
	constexpr float kArrowKeyHeight = kKeyHeight / 2.0;
	constexpr float kWideArrowKeyWidth = 23.0 * kWidthPitch;
	constexpr float kLeftCtrlWidth = 42.0 * kWidthPitch;
	constexpr float kLeftAltWidth = 37.0 * kWidthPitch;
	constexpr float kSpaceWidth = 93.0 * kWidthPitch;
	constexpr float kShiftWidth = 41.0 * kWidthPitch;
	constexpr float kSearchWidth = 32.0 * kWidthPitch;
	constexpr float kEnterWidth = 32.0 * kWidthPitch;
	constexpr float kTabWidth = 27.0 * kWidthPitch;
	constexpr float kBackspaceWidth = 27.0 * kWidthPitch;

	constexpr int kMinTapPressure = 50;
	constexpr int kMaxTapPressure = 110;

	FakeKeyboard::FakeKeyboard() : ff_manager_(kInputWidth) {
	SetUpLayout();
	}

	void FakeKeyboard::SetUpLayout() {
	// This function sets up the key code and their locations.
	// TODO(charliemooney): Currently this has a layout hard-coded into it.
	// Obviously, that's a bad idea. This needs to be updated to load
	// a layout from disk somewhere once things have stabilized a little.
	unsigned int i;
	int row1[] = {KEY_Z, KEY_X, KEY_C, KEY_V, KEY_B, KEY_N, KEY_M, KEY_COMMA,
	KEY_DOT, KEY_SLASH};
	int row2[] = {KEY_A, KEY_S, KEY_D, KEY_F, KEY_G, KEY_H, KEY_J, KEY_K, KEY_L,
	KEY_SEMICOLON, KEY_APOSTROPHE};
	int row3[] = {KEY_Q, KEY_W, KEY_E, KEY_R, KEY_T, KEY_Y, KEY_U, KEY_I,
	KEY_O, KEY_P, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH};
	int row4[] = {KEY_GRAVE, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7,
	KEY_8, KEY_9, KEY_0, KEY_MINUS, KEY_EQUAL};
	int rowfn[] = {KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6,
	KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F13};


	int bottom_row_ymin = kBottomRowYmin;
	layout_.push_back(Key(KEY_LEFTCTRL,
	0,
	kLeftCtrlWidth,
	bottom_row_ymin,
	bottom_row_ymin + kKeyHeight));
	layout_.push_back(Key(KEY_LEFTALT,
	layout_.back().xmax_,
	layout_.back().xmax_ + kLeftAltWidth,
	bottom_row_ymin,
	bottom_row_ymin + kKeyHeight));
	layout_.push_back(Key(KEY_SPACE,
	layout_.back().xmax_,
	layout_.back().xmax_ + kSpaceWidth,
	bottom_row_ymin,
	bottom_row_ymin + kKeyHeight));
	layout_.push_back(Key(KEY_RIGHTALT,
	layout_.back().xmax_,
	layout_.back().xmax_ + kKeyWidth,
	bottom_row_ymin,
	bottom_row_ymin + kKeyHeight));
	layout_.push_back(Key(KEY_RIGHTCTRL,
	layout_.back().xmax_,
	layout_.back().xmax_ + kKeyWidth,
	bottom_row_ymin,
	bottom_row_ymin + kKeyHeight));
	layout_.push_back(Key(KEY_LEFT,
	layout_.back().xmax_,
	layout_.back().xmax_ + kKeyWidth,
	bottom_row_ymin,
	bottom_row_ymin + kArrowKeyHeight));
	layout_.push_back(Key(KEY_DOWN,
	layout_.back().xmax_,
	layout_.back().xmax_ + kWideArrowKeyWidth,
	bottom_row_ymin,
	bottom_row_ymin + kArrowKeyHeight));
	layout_.push_back(Key(KEY_UP,
	layout_.back().xmin_,
	layout_.back().xmax_,
	bottom_row_ymin + kArrowKeyHeight,
	bottom_row_ymin + kKeyWidth));
	layout_.push_back(Key(KEY_RIGHT,
	layout_.back().xmax_,
	layout_.back().xmax_ + kKeyWidth,
	bottom_row_ymin,
	bottom_row_ymin + kArrowKeyHeight));


	int row1_ymin = bottom_row_ymin + kKeyHeight;
	layout_.push_back(Key(KEY_LEFTSHIFT,
	0,
	kShiftWidth,
	row1_ymin,
	row1_ymin + kKeyHeight));
	for (i = 0; i < arraysize(row1); i++) {
	layout_.push_back(Key(row1[i],
	kShiftWidth + i * kKeyWidth,
	kShiftWidth + i * kKeyWidth + kKeyWidth,
	row1_ymin,
	row1_ymin + kKeyHeight));
	}
	layout_.push_back(Key(KEY_RIGHTSHIFT,
	layout_.back().xmax_,
	layout_.back().xmax_ + kShiftWidth,
	row1_ymin,
	row1_ymin + kKeyHeight));

	int row2_ymin = row1_ymin + kKeyHeight;
	layout_.push_back(Key(KEY_LEFTMETA,
	0,
	kSearchWidth,
	row2_ymin,
	row2_ymin + kKeyHeight));
	for (i = 0; i < arraysize(row2); i++) {
	layout_.push_back(Key(row2[i],
	kSearchWidth + i * kKeyWidth,
	kSearchWidth + i * kKeyWidth + kKeyWidth,
	row2_ymin,
	row2_ymin + kKeyHeight));
	}
	layout_.push_back(Key(KEY_ENTER,
	layout_.back().xmax_,
	layout_.back().xmax_ + kEnterWidth,
	row2_ymin,
	row2_ymin + kKeyHeight));

	int row3_ymin = row2_ymin + kKeyHeight;
	layout_.push_back(Key(KEY_TAB,
	0,
	kTabWidth,
	row3_ymin,
	row3_ymin + kKeyHeight));
	for (i = 0; i < arraysize(row3); i++) {
	layout_.push_back(Key(row3[i],
	kTabWidth + i * kKeyWidth,
	kTabWidth + i * kKeyWidth + kKeyWidth,
	row3_ymin,
	row3_ymin + kKeyHeight));
	}

	int row4_ymin = row3_ymin + kKeyHeight;
	for (i = 0; i < arraysize(row4); i++) {
	layout_.push_back(Key(row4[i],
	i * kKeyWidth,
	i * kKeyWidth + kKeyWidth,
	row4_ymin,
	row4_ymin + kKeyHeight));
	}
	layout_.push_back(Key(KEY_BACKSPACE,
	layout_.back().xmax_,
	layout_.back().xmax_ + kBackspaceWidth,
	row4_ymin,
	row4_ymin + kKeyHeight));

	int rowfn_ymin = row4_ymin + kKeyHeight;
	for (i = 0; i < arraysize(rowfn); i++) {
	layout_.push_back(Key(rowfn[i],
	i * kFnKeyWidth,
	i * kFnKeyWidth + kFnKeyWidth,
	rowfn_ymin,
	rowfn_ymin + kFnKeyHeight));
	}
	}


	void FakeKeyboard::EnableKeyboardEvents() const {
	// Enable key events in general for output.
	EnableEventType(EV_KEY);
	// Enable each specific key code found in the layout.
	for (unsigned int i = 0; i < layout_.size(); i++) {
	EnableKeyEvent(layout_[i].event_code_);
	}
	}

	struct timespec FakeKeyboard::AddMsToTimespec(struct timespec const& orig,
	int additional_ms) {
	struct timespec extended = orig;
	extended.tv_nsec += additional_ms * 1e6;
	while (extended.tv_nsec >= 1e9) {
	extended.tv_nsec -= 1e9;
	extended.tv_sec += 1;
	}
	return extended;
	}

	bool FakeKeyboard::TimespecIsLater(struct timespec const& t1,
	struct timespec const& t2) {
	return ((t1.tv_sec > t2.tv_sec) \|\|
	(t1.tv_sec == t2.tv_sec && t1.tv_nsec > t2.tv_nsec));
	}

	int FakeKeyboard::GenerateEventForArrivingFinger(
	struct timespec now,
	struct mtstatemachine::MtFinger const &finger, int tid) {
	for (unsigned int key_num = 0; key_num < layout_.size(); key_num++) {
	if (layout_[key_num].Contains(finger.x, finger.y)) {
	Event ev(layout_[key_num].event_code_, kKeyDownEvent,
	AddMsToTimespec(now, kEventDelayMS), tid);
	EnqueueEvent(ev);
	return key_num;
	}
	}
	return kNoKey;
	}

	void FakeKeyboard::HandleLeavingFinger(int tid, FingerData finger,
	timespec now) {
	bool up_event_guaranteed = false, down_event_guaranteed = false;

	// If the finger has already been marked dead for some reason, ignore it.
	if (finger.rejection_status_ != RejectionStatus::kNotRejectedYet) {
	return;
	}

	// If there is an outstanding down event for this finger and mark it
	// guaranteed.
	if (!finger.down_sent_) {
	std::list<Event>::iterator it = pending_events_.begin();
	while (it != pending_events_.end()) {
	if (it->tid_ == tid) {
	it->is_guaranteed_ = true;
	down_event_guaranteed \|= it->is_down_;
	up_event_guaranteed \|= !it->is_down_;
	break;
	}
	it++;
	}
	}

	// If we're here we either have already sent the key_down event for this
	// finger, or have just marked in guaranteed. Either way we have to enqueue
	// a guaranteed up event now if there isn't one already.
	if (!up_event_guaranteed) {
	EnqueueKeyUpEvent(layout_[finger.starting_key_number_].event_code_, now);
	}
	}

	void FakeKeyboard::EnqueueKeyUpEvent(int ev_code, timespec now) {
	Event up_event(ev_code, kKeyUpEvent,
	AddMsToTimespec(now, kEventDelayMS), kOldTID);
	up_event.is_guaranteed_ = true;
	EnqueueEvent(up_event);
	}

	bool FakeKeyboard::StillOnFirstKey(
	struct mtstatemachine::MtFinger const & finger,
	FingerData const & data) const {
	// If this finger didn't start on a key, then automatically return false.
	if (data.starting_key_number_ == kNoKey) {
	return false;
	}

	// Otherwise, see if it's still contained in that starting key.
	return layout_.at(data.starting_key_number_).Contains(finger.x, finger.y);
	}

	void FakeKeyboard::RejectFinger(int tid, RejectionStatus reason) {
	// First, mark the finger's FingerData as rejected.
	finger_data_[tid].rejection_status_ = reason;

	// Next, scan through the pending events and delete any for that finger.
	std::list<Event>::iterator it = pending_events_.begin();
	while (it != pending_events_.end()) {
	auto current = it++;
	if (current->tid_ == tid) {
	pending_events_.erase(current);
	}
	}
	}

	void FakeKeyboard::ProcessIncomingSnapshot(
	struct timespec now,
	std::unordered_map<int, struct mtstatemachine::MtFinger> const &snapshot) {
	// First we go through all the touches reported by the touchscreen in the most
	// recent snapshot.
	for (auto map_entry : snapshot) {
	int tid = map_entry.first;
	struct mtstatemachine::MtFinger finger = map_entry.second;

	std::unordered_map<int, FingerData>::iterator data_for_tid_it;
	data_for_tid_it = finger_data_.find(tid);
	if (data_for_tid_it == finger_data_.end()) {
	int ev_code_ = GenerateEventForArrivingFinger(now, finger, tid);

	// If this is a newly arriving finger, make a new entry for it and fill
	// out all the starting data we have. In some cases, this may invalidate
	// a finger immediately.
	FingerData data;
	data.arrival_time_ = now;
	data.max_pressure_ = finger.p;
	data.starting_key_number_ = ev_code_;
	data.down_sent_ = false;
	data.rejection_status_ = RejectionStatus::kNotRejectedYet;

	if (ev_code_ == kNoKey) {
	data.rejection_status_ = RejectionStatus::kRejectTouchdownOffKey;
	} else {
	ff_manager_.EventTriggered(TouchKeyboardEvent::FingerDown, finger.x);
	}

	// TODO(charliemooney): Add more data here that can be used for
	// tracking fingers.
	finger_data_[tid] = data;
	} else if (data_for_tid_it->second.rejection_status_ ==
	RejectionStatus::kNotRejectedYet) {
	// If we've seen this finger before, update the data on it.
	// First, Check if the maxium pressure has changed.
	data_for_tid_it->second.max_pressure_ =
	std::max(data_for_tid_it->second.max_pressure_, finger.p);

	// Check if the finger has left the key it started on
	if (!StillOnFirstKey(finger, data_for_tid_it->second)) {
	RejectFinger(data_for_tid_it->first,
	RejectionStatus::kRejectMovedOffKey);
	if (data_for_tid_it->second.down_sent_) {
	// Send a KeyUp event to cancel any held-down buttons.
	EnqueueKeyUpEvent(
	layout_[data_for_tid_it->second.starting_key_number_].event_code_,
	now);
	}
	}

	// TODO(charliemooney): Update the additional data here, once it's added.
	}
	}

	// Next we need to check if there are any fingers missing that we saw before
	// which would indicate a finger leaving the touchscreen.
	std::unordered_map<int, FingerData>::iterator data_it = finger_data_.begin();
	while (data_it != finger_data_.end()) {
	int tid = data_it->first;
	FingerData this_finger_data = data_it->second;
	auto input_it = snapshot.find(tid);
	if (tid != kOldTID && input_it == snapshot.end()) {
	HandleLeavingFinger(tid, this_finger_data, now);
	auto next = data_it;
	next++;
	finger_data_.erase(data_it);
	data_it = next;
	} else {
	data_it++;
	}
	}
	}

	void FakeKeyboard::EnqueueEvent(Event ev) {
	// Find the right place in the queue, maintaining the order.
	std::list<Event>::iterator it = pending_events_.begin();
	while (it != pending_events_.end()) {
	if (TimespecIsLater(it->deadline_, ev.deadline_)) {
	pending_events_.insert(it, ev);
	return;
	}
	it++;
	}

	// If we didn't find a place for it, then it must belong at the end.
	pending_events_.push_back(ev);
	}

	void FakeKeyboard::Consume() {
	while (1) {
	bool needs_syn = false;

	// Compute how long to wait for a timeout. (At most until the next pending
	// event is set to fire)
	struct timespec now;
	clock_gettime(CLOCK_MONOTONIC, &now);
	int timeout_ms = -1; // No timeout if there aren't any pending events.
	if (!pending_events_.empty()) {
	timespec deadline = pending_events_.front().deadline_;
	timeout_ms = ((deadline.tv_sec - now.tv_sec) * 1000 +
	(deadline.tv_nsec - now.tv_nsec) / 1000000);
	timeout_ms++; // Always add 1 more ms so as to not undershoot.
	if (timeout_ms < 0) {
	LOG(WARNING) << "Negative timeout (" << timeout_ms <<
	"). We missed an event somewhere!\n";
	timeout_ms = 1;
	}
	}

	// Wait for a touchscreen event or a timeout. If there's an event from
	// the touchscreen add it to the statemachine. Otherwise, that means it's
	// time to fire the next pending event.
	struct input_event ev;
	bool event_ready = GetNextEvent(timeout_ms, &ev);
	clock_gettime(CLOCK_MONOTONIC, &now);
	if (event_ready) {
	std::unordered_map<int, struct mtstatemachine::MtFinger> snapshot;
	if (sm_.AddEvent(ev, &snapshot)) {
	// Here we process the new snapshot, enqueing events as needed.
	ProcessIncomingSnapshot(now, snapshot);
	} else {
	// If it was a touchscreen event but not the end of a snapshot, then
	// just continue the loop. This allows us to treat touchscreen events
	// as atomic events where the entire snapshot arrives at one time.
	continue;
	}
	}

	// Loop over pending events and process any that are ready to fire.
	while (!pending_events_.empty()) {
	// If the next event's deadline is still in the future, stop looking.
	Event next_event = pending_events_.front();
	if (TimespecIsLater(next_event.deadline_, now)) {
	break;
	}

	// Pop off the next pending event and process it now.
	pending_events_.pop_front();

	// Look up the FingerData associated with this event and make sure the
	// event is still valid.
	std::unordered_map<int, FingerData>::iterator it;
	it = finger_data_.find(next_event.tid_);
	if (it != finger_data_.end()) {
	// Here we check to see if this event is still valid before firing it
	// off to the OS. Currently there is only a pressure check here, but
	// more could easily be added later.

	// This checks if the maximum pressure a finger reported is within
	// range. An exception is made for the spacebar since it is often
	// pressed by a user's thumb, which may have unusually high pressure.
	if (it->second.max_pressure_ < kMinTapPressure \|\|
	(layout_[it->second.starting_key_number_].event_code_ !=
	KEY_SPACE && it->second.max_pressure_ > kMaxTapPressure)) {
	LOG(INFO) << "Tap rejected! Pressure of " <<
	it->second.max_pressure_ << " is out of range " <<
	kMinTapPressure << "->" << kMaxTapPressure;
	continue;
	}
	} else {
	// The finger has already left -- that's OK as long as it is
	// "guaranteed" to fire.
	if (!next_event.is_guaranteed_) {
	LOG(ERROR) << "No finger data for event that should have some! " <<
	"(guaranteed: " << next_event.is_guaranteed_ << ", " <<
	"is_down: " << next_event.is_down_ << ", " <<
	"tid: " << next_event.tid_ << ")";
	}
	}

	// Actually send the event and update the fingerdata if applicable.
	SendEvent(EV_KEY, next_event.ev_code_, next_event.is_down_ ? 1 : 0);
	needs_syn = true;
	if (next_event.is_down_) {
	std::unordered_map<int, FingerData>::iterator it;
	it = finger_data_.find(next_event.tid_);
	if (it != finger_data_.end()) {
	finger_data_[next_event.tid_].down_sent_ = true;
	}
	}
	}
	if (needs_syn) {
	// Finally, send out a SYN after all applicable events are sent.
	SendEvent(EV_SYN, SYN_REPORT, 0);
	}
	}
	}

	void FakeKeyboard::Start(std::string const &source_device_path,
	std::string const &keyboard_device_name) {
	// Do all the set up steps.
	OpenSourceDevice(source_device_path);
	CreateUinputFD();
	EnableKeyboardEvents();
	FinalizeUinputCreation(keyboard_device_name);

	// Loop forever, comsuming the events coming in from the source device and
	// generating keystroke events when appropriate.
	Consume();
	}

	} // namespace touch_keyboard