Home | History | Annotate | Download | only in renderer_host 
      1 // Copyright (c) 2012 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 "content/browser/renderer_host/ime_adapter_android.h"
      6 
      7 #include <algorithm>
      8 #include <android/input.h>
      9 #include <vector>
     10 
     11 #include "base/android/jni_android.h"
     12 #include "base/android/jni_string.h"
     13 #include "base/android/scoped_java_ref.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "base/time/time.h"
     16 #include "content/browser/frame_host/frame_tree.h"
     17 #include "content/browser/frame_host/frame_tree_node.h"
     18 #include "content/browser/frame_host/render_frame_host_impl.h"
     19 #include "content/browser/renderer_host/render_view_host_delegate.h"
     20 #include "content/browser/renderer_host/render_view_host_impl.h"
     21 #include "content/browser/renderer_host/render_widget_host_impl.h"
     22 #include "content/browser/renderer_host/render_widget_host_view_android.h"
     23 #include "content/common/frame_messages.h"
     24 #include "content/common/input_messages.h"
     25 #include "content/common/view_messages.h"
     26 #include "content/public/browser/browser_thread.h"
     27 #include "content/public/browser/native_web_keyboard_event.h"
     28 #include "content/public/browser/web_contents.h"
     29 #include "jni/ImeAdapter_jni.h"
     30 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
     31 #include "third_party/WebKit/public/web/WebInputEvent.h"
     32 #include "third_party/WebKit/public/web/WebTextInputType.h"
     33 
     34 using base::android::AttachCurrentThread;
     35 using base::android::ConvertJavaStringToUTF16;
     36 
     37 namespace content {
     38 namespace {
     39 
     40 // Maps a java KeyEvent into a NativeWebKeyboardEvent.
     41 // |java_key_event| is used to maintain a globalref for KeyEvent.
     42 // |action| will help determine the WebInputEvent type.
     43 // type, |modifiers|, |time_ms|, |key_code|, |unicode_char| is used to create
     44 // WebKeyboardEvent. |key_code| is also needed ad need to treat the enter key
     45 // as a key press of character \r.
     46 NativeWebKeyboardEvent NativeWebKeyboardEventFromKeyEvent(
     47     JNIEnv* env,
     48     jobject java_key_event,
     49     int action,
     50     int modifiers,
     51     long time_ms,
     52     int key_code,
     53     bool is_system_key,
     54     int unicode_char) {
     55   blink::WebInputEvent::Type type = blink::WebInputEvent::Undefined;
     56   if (action == AKEY_EVENT_ACTION_DOWN)
     57     type = blink::WebInputEvent::RawKeyDown;
     58   else if (action == AKEY_EVENT_ACTION_UP)
     59     type = blink::WebInputEvent::KeyUp;
     60   return NativeWebKeyboardEvent(java_key_event, type, modifiers,
     61       time_ms / 1000.0, key_code, unicode_char, is_system_key);
     62 }
     63 
     64 }  // anonymous namespace
     65 
     66 bool RegisterImeAdapter(JNIEnv* env) {
     67   if (!RegisterNativesImpl(env))
     68     return false;
     69 
     70   Java_ImeAdapter_initializeWebInputEvents(env,
     71                                            blink::WebInputEvent::RawKeyDown,
     72                                            blink::WebInputEvent::KeyUp,
     73                                            blink::WebInputEvent::Char,
     74                                            blink::WebInputEvent::ShiftKey,
     75                                            blink::WebInputEvent::AltKey,
     76                                            blink::WebInputEvent::ControlKey,
     77                                            blink::WebInputEvent::CapsLockOn,
     78                                            blink::WebInputEvent::NumLockOn);
     79   Java_ImeAdapter_initializeTextInputTypes(
     80       env,
     81       ui::TEXT_INPUT_TYPE_NONE,
     82       ui::TEXT_INPUT_TYPE_TEXT,
     83       ui::TEXT_INPUT_TYPE_TEXT_AREA,
     84       ui::TEXT_INPUT_TYPE_PASSWORD,
     85       ui::TEXT_INPUT_TYPE_SEARCH,
     86       ui::TEXT_INPUT_TYPE_URL,
     87       ui::TEXT_INPUT_TYPE_EMAIL,
     88       ui::TEXT_INPUT_TYPE_TELEPHONE,
     89       ui::TEXT_INPUT_TYPE_NUMBER,
     90       ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE);
     91   Java_ImeAdapter_initializeTextInputFlags(
     92       env,
     93       blink::WebTextInputFlagAutocompleteOn,
     94       blink::WebTextInputFlagAutocompleteOff,
     95       blink::WebTextInputFlagAutocorrectOn,
     96       blink::WebTextInputFlagAutocorrectOff,
     97       blink::WebTextInputFlagSpellcheckOn,
     98       blink::WebTextInputFlagSpellcheckOff);
     99   return true;
    100 }
    101 
    102 // Callback from Java to convert BackgroundColorSpan data to a
    103 // blink::WebCompositionUnderline instance, and append it to |underlines_ptr|.
    104 void AppendBackgroundColorSpan(JNIEnv*,
    105                                jclass,
    106                                jlong underlines_ptr,
    107                                jint start,
    108                                jint end,
    109                                jint background_color) {
    110   DCHECK(start >= 0);
    111   DCHECK(end >= 0);
    112   // Do not check |background_color|.
    113   std::vector<blink::WebCompositionUnderline>* underlines =
    114       reinterpret_cast<std::vector<blink::WebCompositionUnderline>*>(
    115           underlines_ptr);
    116   underlines->push_back(
    117       blink::WebCompositionUnderline(static_cast<unsigned>(start),
    118                                      static_cast<unsigned>(end),
    119                                      SK_ColorTRANSPARENT,
    120                                      false,
    121                                      static_cast<unsigned>(background_color)));
    122 }
    123 
    124 // Callback from Java to convert UnderlineSpan data to a
    125 // blink::WebCompositionUnderline instance, and append it to |underlines_ptr|.
    126 void AppendUnderlineSpan(JNIEnv*,
    127                          jclass,
    128                          jlong underlines_ptr,
    129                          jint start,
    130                          jint end) {
    131   DCHECK(start >= 0);
    132   DCHECK(end >= 0);
    133   std::vector<blink::WebCompositionUnderline>* underlines =
    134       reinterpret_cast<std::vector<blink::WebCompositionUnderline>*>(
    135           underlines_ptr);
    136   underlines->push_back(
    137       blink::WebCompositionUnderline(static_cast<unsigned>(start),
    138                                      static_cast<unsigned>(end),
    139                                      SK_ColorBLACK,
    140                                      false,
    141                                      SK_ColorTRANSPARENT));
    142 }
    143 
    144 ImeAdapterAndroid::ImeAdapterAndroid(RenderWidgetHostViewAndroid* rwhva)
    145     : rwhva_(rwhva) {
    146 }
    147 
    148 ImeAdapterAndroid::~ImeAdapterAndroid() {
    149   JNIEnv* env = AttachCurrentThread();
    150   base::android::ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
    151   if (!obj.is_null())
    152     Java_ImeAdapter_detach(env, obj.obj());
    153 }
    154 
    155 bool ImeAdapterAndroid::SendSyntheticKeyEvent(JNIEnv*,
    156                                               jobject,
    157                                               int type,
    158                                               long time_ms,
    159                                               int key_code,
    160                                               int modifiers,
    161                                               int text) {
    162   NativeWebKeyboardEvent event(static_cast<blink::WebInputEvent::Type>(type),
    163                                modifiers, time_ms / 1000.0, key_code,
    164                                text, false /* is_system_key */);
    165   rwhva_->SendKeyEvent(event);
    166   return true;
    167 }
    168 
    169 bool ImeAdapterAndroid::SendKeyEvent(JNIEnv* env, jobject,
    170                                      jobject original_key_event,
    171                                      int action, int modifiers,
    172                                      long time_ms, int key_code,
    173                                      bool is_system_key, int unicode_char) {
    174   NativeWebKeyboardEvent event = NativeWebKeyboardEventFromKeyEvent(
    175           env, original_key_event, action, modifiers,
    176           time_ms, key_code, is_system_key, unicode_char);
    177   bool key_down_text_insertion =
    178       event.type == blink::WebInputEvent::RawKeyDown && event.text[0];
    179   // If we are going to follow up with a synthetic Char event, then that's the
    180   // one we expect to test if it's handled or unhandled, so skip handling the
    181   // "real" event in the browser.
    182   event.skip_in_browser = key_down_text_insertion;
    183   rwhva_->SendKeyEvent(event);
    184   if (key_down_text_insertion) {
    185     // Send a Char event, but without an os_event since we don't want to
    186     // roundtrip back to java such synthetic event.
    187     NativeWebKeyboardEvent char_event(blink::WebInputEvent::Char, modifiers,
    188                                       time_ms / 1000.0, key_code, unicode_char,
    189                                       is_system_key);
    190     char_event.skip_in_browser = key_down_text_insertion;
    191     rwhva_->SendKeyEvent(char_event);
    192   }
    193   return true;
    194 }
    195 
    196 void ImeAdapterAndroid::SetComposingText(JNIEnv* env,
    197                                          jobject obj,
    198                                          jobject text,
    199                                          jstring text_str,
    200                                          int new_cursor_pos) {
    201   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
    202   if (!rwhi)
    203     return;
    204 
    205   base::string16 text16 = ConvertJavaStringToUTF16(env, text_str);
    206 
    207   std::vector<blink::WebCompositionUnderline> underlines;
    208   // Iterate over spans in |text|, dispatch those that we care about (e.g.,
    209   // BackgroundColorSpan) to a matching callback (e.g.,
    210   // AppendBackgroundColorSpan()), and populate |underlines|.
    211   Java_ImeAdapter_populateUnderlinesFromSpans(
    212       env, obj, text, reinterpret_cast<jlong>(&underlines));
    213 
    214   // Default to plain underline if we didn't find any span that we care about.
    215   if (underlines.empty()) {
    216     underlines.push_back(blink::WebCompositionUnderline(
    217         0, text16.length(), SK_ColorBLACK, false, SK_ColorTRANSPARENT));
    218   }
    219   // Sort spans by |.startOffset|.
    220   std::sort(underlines.begin(), underlines.end());
    221 
    222   // new_cursor_position is as described in the Android API for
    223   // InputConnection#setComposingText, whereas the parameters for
    224   // ImeSetComposition are relative to the start of the composition.
    225   if (new_cursor_pos > 0)
    226     new_cursor_pos = text16.length() + new_cursor_pos - 1;
    227 
    228   rwhi->ImeSetComposition(text16, underlines, new_cursor_pos, new_cursor_pos);
    229 }
    230 
    231 void ImeAdapterAndroid::CommitText(JNIEnv* env, jobject, jstring text_str) {
    232   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
    233   if (!rwhi)
    234     return;
    235 
    236   base::string16 text16 = ConvertJavaStringToUTF16(env, text_str);
    237   rwhi->ImeConfirmComposition(text16, gfx::Range::InvalidRange(), false);
    238 }
    239 
    240 void ImeAdapterAndroid::FinishComposingText(JNIEnv* env, jobject) {
    241   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
    242   if (!rwhi)
    243     return;
    244 
    245   rwhi->ImeConfirmComposition(base::string16(), gfx::Range::InvalidRange(),
    246                               true);
    247 }
    248 
    249 void ImeAdapterAndroid::AttachImeAdapter(JNIEnv* env, jobject java_object) {
    250   java_ime_adapter_ = JavaObjectWeakGlobalRef(env, java_object);
    251 }
    252 
    253 void ImeAdapterAndroid::CancelComposition() {
    254   base::android::ScopedJavaLocalRef<jobject> obj =
    255       java_ime_adapter_.get(AttachCurrentThread());
    256   if (!obj.is_null())
    257     Java_ImeAdapter_cancelComposition(AttachCurrentThread(), obj.obj());
    258 }
    259 
    260 void ImeAdapterAndroid::FocusedNodeChanged(bool is_editable_node) {
    261   base::android::ScopedJavaLocalRef<jobject> obj =
    262       java_ime_adapter_.get(AttachCurrentThread());
    263   if (!obj.is_null()) {
    264     Java_ImeAdapter_focusedNodeChanged(AttachCurrentThread(),
    265                                        obj.obj(),
    266                                        is_editable_node);
    267   }
    268 }
    269 
    270 void ImeAdapterAndroid::SetEditableSelectionOffsets(JNIEnv*, jobject,
    271                                                     int start, int end) {
    272   RenderFrameHost* rfh = GetFocusedFrame();
    273   if (!rfh)
    274     return;
    275 
    276   rfh->Send(new FrameMsg_SetEditableSelectionOffsets(rfh->GetRoutingID(),
    277                                                      start, end));
    278 }
    279 
    280 void ImeAdapterAndroid::SetComposingRegion(JNIEnv*, jobject,
    281                                            int start, int end) {
    282   RenderFrameHost* rfh = GetFocusedFrame();
    283   if (!rfh)
    284     return;
    285 
    286   std::vector<blink::WebCompositionUnderline> underlines;
    287   underlines.push_back(blink::WebCompositionUnderline(
    288       0, end - start, SK_ColorBLACK, false, SK_ColorTRANSPARENT));
    289 
    290   rfh->Send(new InputMsg_SetCompositionFromExistingText(
    291       rfh->GetRoutingID(), start, end, underlines));
    292 }
    293 
    294 void ImeAdapterAndroid::DeleteSurroundingText(JNIEnv*, jobject,
    295                                               int before, int after) {
    296   RenderFrameHostImpl* rfh =
    297       static_cast<RenderFrameHostImpl*>(GetFocusedFrame());
    298   if (rfh)
    299     rfh->ExtendSelectionAndDelete(before, after);
    300 }
    301 
    302 void ImeAdapterAndroid::Unselect(JNIEnv* env, jobject) {
    303   WebContents* wc = GetWebContents();
    304   if (wc)
    305     wc->Unselect();
    306 }
    307 
    308 void ImeAdapterAndroid::SelectAll(JNIEnv* env, jobject) {
    309   WebContents* wc = GetWebContents();
    310   if (wc)
    311     wc->SelectAll();
    312 }
    313 
    314 void ImeAdapterAndroid::Cut(JNIEnv* env, jobject) {
    315   WebContents* wc = GetWebContents();
    316   if (wc)
    317     wc->Cut();
    318 }
    319 
    320 void ImeAdapterAndroid::Copy(JNIEnv* env, jobject) {
    321   WebContents* wc = GetWebContents();
    322   if (wc)
    323     wc->Copy();
    324 }
    325 
    326 void ImeAdapterAndroid::Paste(JNIEnv* env, jobject) {
    327   WebContents* wc = GetWebContents();
    328   if (wc)
    329     wc->Paste();
    330 }
    331 
    332 void ImeAdapterAndroid::ResetImeAdapter(JNIEnv* env, jobject) {
    333   java_ime_adapter_.reset();
    334 }
    335 
    336 RenderWidgetHostImpl* ImeAdapterAndroid::GetRenderWidgetHostImpl() {
    337   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    338   DCHECK(rwhva_);
    339   RenderWidgetHost* rwh = rwhva_->GetRenderWidgetHost();
    340   if (!rwh)
    341     return NULL;
    342 
    343   return RenderWidgetHostImpl::From(rwh);
    344 }
    345 
    346 RenderFrameHost* ImeAdapterAndroid::GetFocusedFrame() {
    347   RenderWidgetHostImpl* rwh = GetRenderWidgetHostImpl();
    348   if (!rwh)
    349     return NULL;
    350   if (!rwh->IsRenderView())
    351     return NULL;
    352   RenderViewHost* rvh = RenderViewHost::From(rwh);
    353   FrameTreeNode* focused_frame =
    354       rvh->GetDelegate()->GetFrameTree()->GetFocusedFrame();
    355   if (!focused_frame)
    356     return NULL;
    357 
    358   return focused_frame->current_frame_host();
    359 }
    360 
    361 WebContents* ImeAdapterAndroid::GetWebContents() {
    362   RenderWidgetHostImpl* rwh = GetRenderWidgetHostImpl();
    363   if (!rwh)
    364     return NULL;
    365   if (!rwh->IsRenderView())
    366     return NULL;
    367   return WebContents::FromRenderViewHost(RenderViewHost::From(rwh));
    368 }
    369 
    370 }  // namespace content
    371