Add spellcheck and word suggestion to the prediction service
Add suggestion strip to the keyboard service
Add default English dictionary
Add Android LatinIME/native/jni/src suggestion codebase to third_party/android_prediction
Modify keyboard client text display
R=anwilson@chromium.org, viettrungluu@chromium.org
Review URL: https://codereview.chromium.org/1247903003 .
diff --git a/services/prediction/proximity_info_factory.cc b/services/prediction/proximity_info_factory.cc
new file mode 100644
index 0000000..2c501f8
--- /dev/null
+++ b/services/prediction/proximity_info_factory.cc
@@ -0,0 +1,190 @@
+// Copyright 2015 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 <algorithm>
+#include <cmath>
+#include <new>
+#include <vector>
+
+#include "services/prediction/proximity_info_factory.h"
+#include "services/prediction/touch_position_correction.h"
+
+// NOTE: This class has been translated to C++ and modified from the Android
+// Open Source Project. Specifically from some functions of the following file:
+// https://android.googlesource.com/platform/packages/inputmethods/LatinIME/+/
+// android-5.1.1_r8/java/src/com/android/inputmethod/keyboard/ProximityInfo.java
+
+namespace prediction {
+
+const float ProximityInfoFactory::SEARCH_DISTANCE = 1.2f;
+
+const float ProximityInfoFactory::DEFAULT_TOUCH_POSITION_CORRECTION_RADIUS =
+ 0.15f;
+
+// Hardcoded qwerty keyboard proximity settings
+ProximityInfoFactory::ProximityInfoFactory() {
+ plocale_ = "en";
+ pgrid_width_ = 32;
+ pgrid_height_ = 16;
+ pgrid_size_ = pgrid_width_ * pgrid_height_;
+ pcell_width_ = (348 + pgrid_width_ - 1) / pgrid_width_;
+ pcell_height_ = (174 + pgrid_height_ - 1) / pgrid_height_;
+ pkeyboard_min_width_ = 348;
+ pkeyboard_height_ = 174;
+ pmost_common_key_height_ = 29;
+ pmost_common_key_width_ = 58;
+}
+
+ProximityInfoFactory::~ProximityInfoFactory() {
+}
+
+latinime::ProximityInfo* ProximityInfoFactory::GetNativeProximityInfo() {
+ const int default_width = pmost_common_key_width_;
+ const int threshold = (int)(default_width * SEARCH_DISTANCE);
+ const int threshold_squared = threshold * threshold;
+ const int last_pixel_x_coordinate = pgrid_width_ * pcell_width_ - 1;
+ const int last_pixel_y_coordinate = pgrid_height_ * pcell_height_ - 1;
+
+ std::vector<Key> pgrid_neighbors[32 * 16 /*pgrid_size_*/];
+ int neighbor_count_per_cell[pgrid_size_];
+ std::fill_n(neighbor_count_per_cell, pgrid_size_, 0);
+ Key neighbors_flat_buffer[32 * 16 * 26 /*pgrid_size_ * keyset::key_count*/];
+
+ const int half_cell_width = pcell_width_ / 2;
+ const int half_cell_height = pcell_height_ / 2;
+ for (int i = 0; i < keyset::key_count; i++) {
+ const Key key = keyset::key_set[i];
+
+ const int key_x = key.kx;
+ const int key_y = key.ky;
+ const int top_pixel_within_threshold = key_y - threshold;
+ const int y_delta_to_grid = top_pixel_within_threshold % pcell_height_;
+ const int y_middle_of_top_cell =
+ top_pixel_within_threshold - y_delta_to_grid + half_cell_height;
+ const int y_start =
+ std::max(half_cell_height,
+ y_middle_of_top_cell +
+ (y_delta_to_grid <= half_cell_height ? 0 : pcell_height_));
+ const int y_end =
+ std::min(last_pixel_y_coordinate, key_y + key.kheight + threshold);
+
+ const int left_pixel_within_threshold = key_x - threshold;
+ const int x_delta_to_grid = left_pixel_within_threshold % pcell_width_;
+ const int x_middle_of_left_cell =
+ left_pixel_within_threshold - x_delta_to_grid + half_cell_width;
+ const int x_start =
+ std::max(half_cell_width,
+ x_middle_of_left_cell +
+ (x_delta_to_grid <= half_cell_width ? 0 : pcell_width_));
+ const int x_end =
+ std::min(last_pixel_x_coordinate, key_x + key.kwidth + threshold);
+
+ int base_index_of_current_row =
+ (y_start / pcell_height_) * pgrid_width_ + (x_start / pcell_width_);
+ for (int center_y = y_start; center_y <= y_end; center_y += pcell_height_) {
+ int index = base_index_of_current_row;
+ for (int center_x = x_start; center_x <= x_end;
+ center_x += pcell_width_) {
+ if (SquaredDistanceToEdge(center_x, center_y, key) <
+ threshold_squared) {
+ neighbors_flat_buffer[index * keyset::key_count +
+ neighbor_count_per_cell[index]] =
+ keyset::key_set[i];
+ ++neighbor_count_per_cell[index];
+ }
+ ++index;
+ }
+ base_index_of_current_row += pgrid_width_;
+ }
+ }
+
+ for (int i = 0; i < pgrid_size_; ++i) {
+ const int index_start = i * keyset::key_count;
+ const int index_end = index_start + neighbor_count_per_cell[i];
+ for (int index = index_start; index < index_end; index++) {
+ pgrid_neighbors[i].push_back(neighbors_flat_buffer[index]);
+ }
+ }
+
+ int proximity_chars_array[pgrid_size_ * MAX_PROXIMITY_CHARS_SIZE];
+ for (int i = 0; i < pgrid_size_; i++) {
+ int info_index = i * MAX_PROXIMITY_CHARS_SIZE;
+ for (int j = 0; j < neighbor_count_per_cell[i]; j++) {
+ Key neighbor_key = pgrid_neighbors[i][j];
+ proximity_chars_array[info_index] = neighbor_key.kcode;
+ info_index++;
+ }
+ }
+
+ int key_x_coordinates[keyset::key_count];
+ int key_y_coordinates[keyset::key_count];
+ int key_widths[keyset::key_count];
+ int key_heights[keyset::key_count];
+ int key_char_codes[keyset::key_count];
+ float sweet_spot_center_xs[keyset::key_count];
+ float sweet_spot_center_ys[keyset::key_count];
+ float sweet_spot_radii[keyset::key_count];
+
+ for (int key_index = 0; key_index < keyset::key_count; key_index++) {
+ Key key = keyset::key_set[key_index];
+ key_x_coordinates[key_index] = key.kx;
+ key_y_coordinates[key_index] = key.ky;
+ key_widths[key_index] = key.kwidth;
+ key_heights[key_index] = key.kheight;
+ key_char_codes[key_index] = key.kcode;
+ }
+
+ TouchPositionCorrection touch_position_correction;
+ if (touch_position_correction.IsValid()) {
+ const int rows = touch_position_correction.GetRows();
+ const float default_radius =
+ DEFAULT_TOUCH_POSITION_CORRECTION_RADIUS *
+ (float)std::hypot(pmost_common_key_width_, pmost_common_key_height_);
+ for (int key_index = 0; key_index < keyset::key_count; key_index++) {
+ Key key = keyset::key_set[key_index];
+ sweet_spot_center_xs[key_index] =
+ (key.khit_box_left + key.khit_box_right) * 0.5f;
+ sweet_spot_center_ys[key_index] =
+ (key.khit_box_top + key.khit_box_bottom) * 0.5f;
+ sweet_spot_radii[key_index] = default_radius;
+ const int row = key.khit_box_top / pmost_common_key_height_;
+ if (row < rows) {
+ const int hit_box_width = key.khit_box_right - key.khit_box_left;
+ const int hit_box_height = key.khit_box_bottom - key.khit_box_top;
+ const float hit_box_diagonal =
+ (float)std::hypot(hit_box_width, hit_box_height);
+ sweet_spot_center_xs[key_index] +=
+ touch_position_correction.GetX(row) * hit_box_width;
+ sweet_spot_center_ys[key_index] +=
+ touch_position_correction.GetY(row) * hit_box_height;
+ sweet_spot_radii[key_index] =
+ touch_position_correction.GetRadius(row) * hit_box_diagonal;
+ }
+ }
+ }
+
+ latinime::ProximityInfo* proximity_info = new latinime::ProximityInfo(
+ plocale_, pkeyboard_min_width_, pkeyboard_height_, pgrid_width_,
+ pgrid_height_, pmost_common_key_width_, pmost_common_key_height_,
+ proximity_chars_array, pgrid_size_ * MAX_PROXIMITY_CHARS_SIZE,
+ keyset::key_count, key_x_coordinates, key_y_coordinates, key_widths,
+ key_heights, key_char_codes, sweet_spot_center_xs, sweet_spot_center_ys,
+ sweet_spot_radii);
+
+ return proximity_info;
+}
+
+int ProximityInfoFactory::SquaredDistanceToEdge(int x, int y, Key k) {
+ const int left = k.kx;
+ const int right = left + k.kwidth;
+ const int top = k.ky;
+ const int bottom = top + k.kheight;
+ const int edge_x = x < left ? left : (x > right ? right : x);
+ const int edge_y = y < top ? top : (y > bottom ? bottom : y);
+ const int dx = x - edge_x;
+ const int dy = y - edge_y;
+ return dx * dx + dy * dy;
+}
+
+} // namespace prediction
\ No newline at end of file
