initial version of auto VK switching.

chrome/browser/chromeos/cros/input_method_library.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/input_method_library.h"
 
 #include <algorithm>
 
 #include <glib.h>
 
 #include "unicode/uloc.h"
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
+#include "chrome/browser/chromeos/input_method/virtual_keyboard_selector.h"
 #include "chrome/browser/chromeos/input_method/xkeyboard.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
 #include "content/common/notification_service.h"
+#include "googleurl/src/gurl.h"
 
 #if !defined(TOUCH_UI)
 #include "chrome/browser/chromeos/input_method/candidate_window.h"
 #endif
 
 namespace {
 
 const char kIBusDaemonPath[] = "/usr/bin/ibus-daemon";
 
 // Finds a property which has |new_prop.key| from |prop_list|, and replaces the
@@ skipping 78 matching lines @@
     if (!observers_.size()) {
       observer->FirstObserverIsAdded(this);
     }
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) {
     observers_.RemoveObserver(observer);
   }
 
+  virtual void AddVirtualKeyboardObserver(VirtualKeyboardObserver* observer) {
+    virtual_keyboard_observers_.AddObserver(observer);
+  }
+
+  virtual void RemoveVirtualKeyboardObserver(
+      VirtualKeyboardObserver* observer) {
+    virtual_keyboard_observers_.RemoveObserver(observer);
+  }
+
   virtual InputMethodDescriptors* GetActiveInputMethods() {
     chromeos::InputMethodDescriptors* result =
         new chromeos::InputMethodDescriptors;
     // Build the active input method descriptors from the active input
     // methods cache |active_input_method_ids_|.
     for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
       const std::string& input_method_id = active_input_method_ids_[i];
       const InputMethodDescriptor* descriptor =
           chromeos::input_method::GetInputMethodDescriptorFromId(
               input_method_id);
@@ skipping 141 matching lines @@
     chromeos::SendHandwritingStroke(input_method_status_connection_, stroke);
   }
 
   virtual void CancelHandwritingStrokes(int stroke_count) {
     if (!initialized_successfully_)
       return;
     // TODO(yusukes): Rename the libcros function to CancelHandwritingStrokes.
     chromeos::CancelHandwriting(input_method_status_connection_, stroke_count);
   }
 
+  virtual void RegisterVirtualKeyboard(const GURL& launch_url,
+                                       const std::set<std::string>& layouts,
+                                       bool is_system) {
+    if (!initialized_successfully_)
+      return;
+    virtual_keyboard_selector.AddVirtualKeyboard(launch_url,
+                                                 layouts,
+                                                 is_system);
+  }
+
  private:
   // Returns true if the given input method config value is a single
   // element string list that contains an input method ID of a keyboard
   // layout.
   bool ContainOnlyOneKeyboardLayout(
       const ImeConfigValue& value) {
     return (value.type == ImeConfigValue::kValueTypeStringList &&
             value.string_list_value.size() == 1 &&
             chromeos::input_method::IsKeyboardLayout(
                 value.string_list_value[0]));
@@ skipping 324 matching lines @@
     }
 
     // Update input method indicators (e.g. "US", "DV") in Chrome windows.
     // For now, we have to do this every time to keep indicators updated. See
     // comments near the FOR_EACH_OBSERVER call in FlushImeConfig() for details.
     const size_t num_active_input_methods = GetNumActiveInputMethods();
     FOR_EACH_OBSERVER(Observer, observers_,
                       InputMethodChanged(this,
                                          current_input_method_,
                                          num_active_input_methods));
+
+    // Update virtual keyboard.
+#if defined(TOUCH_UI)
+    const input_method::VirtualKeyboard* virtual_keyboard = NULL;
+    std::string virtual_keyboard_layout = "";
+
+    static const char kFallbackLayout[] = "us";
+    std::vector<std::string> layouts_vector
+        = current_input_method_.virtual_keyboard_layouts();
+    layouts_vector.push_back(kFallbackLayout);
+
+    for (size_t i = 0; i < layouts_vector.size(); ++i) {
+      virtual_keyboard =
+          virtual_keyboard_selector.SelectVirtualKeyboard(layouts_vector[i]);
+      if (virtual_keyboard) {
+        virtual_keyboard_layout = layouts_vector[i];
+        if (i == layouts_vector.size() - 1) {
+          // The system virtual keyboard does not support some XKB layouts? or
+          // a third-party input method engine uses a wrong virtual keyboard
+          // layout name? Fallback to the default layout.
+          LOG(ERROR) << "Could not find a virtual keyboard for "
+                     << current_input_method_.id
+                     << ". Use '" << kFallbackLayout << "' virtual keyboard.";
+        }
+        break;
+      }
+    }
+    // kFallbackLayout should always be supported by one of the system virtual
+    // keyboards.
+    DCHECK(virtual_keyboard);
+
+    if (virtual_keyboard) {
+      FOR_EACH_OBSERVER(VirtualKeyboardObserver, virtual_keyboard_observers_,
+                        VirtualKeyboardChanged(this,
+                                               *virtual_keyboard,
+                                               virtual_keyboard_layout));
+    }
+#endif  // TOUCH_UI
   }
 
   // Changes the current input method from the given input method ID.
   // This function is just a wrapper of ChangeCurrentInputMethod().
   void ChangeCurrentInputMethodFromId(const std::string& input_method_id) {
     const chromeos::InputMethodDescriptor* descriptor =
         chromeos::input_method::GetInputMethodDescriptorFromId(
             input_method_id);
     if (descriptor) {
       ChangeCurrentInputMethod(*descriptor);
@@ skipping 159 matching lines @@
 #if !defined(TOUCH_UI)
       candidate_window_controller_.reset(NULL);
 #endif
     }
   }
 
   // A reference to the language api, to allow callbacks when the input method
   // status changes.
   InputMethodStatusConnection* input_method_status_connection_;
   ObserverList<Observer> observers_;
+  ObserverList<VirtualKeyboardObserver> virtual_keyboard_observers_;
 
   // The input method which was/is selected.
   InputMethodDescriptor previous_input_method_;
   InputMethodDescriptor current_input_method_;
 
   // The input method properties which the current input method uses. The list
   // might be empty when no input method is used.
   ImePropertyList current_ime_properties_;
 
   typedef std::pair<std::string, std::string> ConfigKeyType;
@@ skipping 36 matching lines @@
   // loaded and input method status monitoring is started. This value
   // should be checked where we call libcros functions.
   bool initialized_successfully_;
 
   // The candidate window.  This will be deleted when the APP_TERMINATING
   // message is sent.
 #if !defined(TOUCH_UI)
   scoped_ptr<CandidateWindowController> candidate_window_controller_;
 #endif
 
+  // An object which keeps a list of available virtual keyboards.
+  input_method::VirtualKeyboardSelector virtual_keyboard_selector;
+
   // The active input method ids cache.
   std::vector<std::string> active_input_method_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(InputMethodLibraryImpl);
 };
 
 InputMethodLibraryImpl::Observer::~Observer() {}
+InputMethodLibraryImpl::VirtualKeyboardObserver::~VirtualKeyboardObserver() {}
 
 // The stub implementation of InputMethodLibrary. Used for testing.
 class InputMethodLibraryStubImpl : public InputMethodLibrary {
  public:
   InputMethodLibraryStubImpl()
       : keyboard_overlay_map_(GetKeyboardOverlayMapForTesting()) {
     current_input_method_ = input_method::GetFallbackInputMethodDescriptor();
   }
 
   virtual ~InputMethodLibraryStubImpl() {}
   virtual void AddObserver(Observer* observer) {}
+  virtual void AddVirtualKeyboardObserver(VirtualKeyboardObserver* observer) {}
   virtual void RemoveObserver(Observer* observer) {}
+  virtual void RemoveVirtualKeyboardObserver(
+      VirtualKeyboardObserver* observer) {}
 
   virtual InputMethodDescriptors* GetActiveInputMethods() {
     return GetInputMethodDescriptorsForTesting();
   }
 
 
   virtual size_t GetNumActiveInputMethods() {
     scoped_ptr<InputMethodDescriptors> descriptors(GetActiveInputMethods());
     return descriptors->size();
   }
@@ skipping 37 matching lines @@
 
   virtual std::string GetKeyboardOverlayId(const std::string& input_method_id) {
     KeyboardOverlayMap::const_iterator iter =
         keyboard_overlay_map_->find(input_method_id);
     return (iter != keyboard_overlay_map_->end()) ?
         iter->second : "";
   }
 
   virtual void SendHandwritingStroke(const HandwritingStroke& stroke) {}
   virtual void CancelHandwritingStrokes(int stroke_count) {}
+  virtual void RegisterVirtualKeyboard(const GURL& launch_url,
+                                       const std::set<std::string>& layouts,
+                                       bool is_system) {}
 
  private:
   typedef std::map<std::string, std::string> KeyboardOverlayMap;
 
   // Gets input method descriptors for testing. Shouldn't be used for
   // production.
   InputMethodDescriptors* GetInputMethodDescriptorsForTesting() {
     InputMethodDescriptors* descriptions = new InputMethodDescriptors;
     // The list is created from output of gen_engines.py in libcros.
     // % SHARE=/build/x86-generic/usr/share python gen_engines.py
@@ skipping 243 matching lines @@
     }
     return impl;
   }
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::InputMethodLibraryImpl);