extensions/browser/api/virtual_keyboard_private/virtual_keyboard_private_api.cc

   1 // Copyright 2014 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 "extensions/browser/api/virtual_keyboard_private/virtual_keyboard_private_api.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/strings/string16.h"
   9 #include "extensions/browser/api/extensions_api_client.h"
  10 #include "extensions/browser/api/virtual_keyboard_private/virtual_keyboard_delegate.h"
  11 #include "extensions/browser/extension_function_registry.h"
  12 #include "extensions/common/api/virtual_keyboard_private.h"
  13 #include "ui/events/event.h"
  14
  15 namespace SetMode = extensions::api::virtual_keyboard_private::SetMode;
  16 namespace SetRequestedKeyboardState =
  17     extensions::api::virtual_keyboard_private::SetKeyboardState;
  18
  19 namespace extensions {
  20
  21 namespace {
  22
  23 const char kNotYetImplementedError[] =
  24     "API is not implemented on this platform.";
  25 const char kVirtualKeyboardNotEnabled[] =
  26     "The virtual keyboard is not enabled.";
  27
  28 typedef BrowserContextKeyedAPIFactory<VirtualKeyboardAPI> factory;
  29
  30 VirtualKeyboardDelegate* GetDelegate(SyncExtensionFunction* f) {
  31   VirtualKeyboardAPI* api = factory::Get(f->browser_context());
  32   DCHECK(api);
  33   return api ? api->delegate() : nullptr;
  34 }
  35
  36 }  // namespace
  37
  38 bool VirtualKeyboardPrivateInsertTextFunction::RunSync() {
  39   VirtualKeyboardDelegate* delegate = GetDelegate(this);
  40   if (delegate) {
  41     base::string16 text;
  42     EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &text));
  43     return delegate->InsertText(text);
  44   }
  45   error_ = kNotYetImplementedError;
  46   return false;
  47 }
  48
  49 bool VirtualKeyboardPrivateSendKeyEventFunction::RunSync() {
  50   VirtualKeyboardDelegate* delegate = GetDelegate(this);
  51   if (delegate) {
  52     base::Value* options_value = nullptr;
  53     base::DictionaryValue* params = nullptr;
  54     std::string type;
  55     int char_value;
  56     int key_code;
  57     std::string key_name;
  58     int modifiers;
  59
  60     EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &options_value));
  61     EXTENSION_FUNCTION_VALIDATE(options_value->GetAsDictionary(&params));
  62     EXTENSION_FUNCTION_VALIDATE(params->GetString("type", &type));
  63     EXTENSION_FUNCTION_VALIDATE(params->GetInteger("charValue", &char_value));
  64     EXTENSION_FUNCTION_VALIDATE(params->GetInteger("keyCode", &key_code));
  65     EXTENSION_FUNCTION_VALIDATE(params->GetString("keyName", &key_name));
  66     EXTENSION_FUNCTION_VALIDATE(params->GetInteger("modifiers", &modifiers));
  67     return delegate->SendKeyEvent(
  68         type, char_value, key_code, key_name, modifiers);
  69   }
  70   error_ = kNotYetImplementedError;
  71   return false;
  72 }
  73
  74 bool VirtualKeyboardPrivateHideKeyboardFunction::RunSync() {
  75   VirtualKeyboardDelegate* delegate = GetDelegate(this);
  76   if (delegate)
  77     return delegate->HideKeyboard();
  78   error_ = kNotYetImplementedError;
  79   return false;
  80 }
  81
  82 bool VirtualKeyboardPrivateLockKeyboardFunction::RunSync() {
  83   VirtualKeyboardDelegate* delegate = GetDelegate(this);
  84   if (delegate) {
  85     bool lock;
  86     EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(0, &lock));
  87     return delegate->LockKeyboard(lock);
  88   }
  89   error_ = kNotYetImplementedError;
  90   return false;
  91 }
  92
  93 bool VirtualKeyboardPrivateKeyboardLoadedFunction::RunSync() {
  94   VirtualKeyboardDelegate* delegate = GetDelegate(this);
  95   if (delegate)
  96     return delegate->OnKeyboardLoaded();
  97   error_ = kNotYetImplementedError;
  98   return false;
  99 }
 100
 101 bool VirtualKeyboardPrivateGetKeyboardConfigFunction::RunSync() {
 102   VirtualKeyboardDelegate* delegate = GetDelegate(this);
 103   if (delegate) {
 104     base::DictionaryValue* results = new base::DictionaryValue();
 105     if (delegate->GetKeyboardConfig(results)) {
 106       SetResult(results);
 107       return true;
 108     }
 109   }
 110   return false;
 111 }
 112
 113 bool VirtualKeyboardPrivateOpenSettingsFunction::RunSync() {
 114   VirtualKeyboardDelegate* delegate = GetDelegate(this);
 115   if (delegate) {
 116     if (delegate->IsLanguageSettingsEnabled())
 117       return delegate->ShowLanguageSettings();
 118     return false;
 119   }
 120   error_ = kNotYetImplementedError;
 121   return false;
 122 }
 123
 124 bool VirtualKeyboardPrivateSetModeFunction::RunSync() {
 125   VirtualKeyboardDelegate* delegate = GetDelegate(this);
 126   if (delegate) {
 127     scoped_ptr<SetMode::Params> params = SetMode::Params::Create(*args_);
 128     EXTENSION_FUNCTION_VALIDATE(params);
 129     if (!delegate->SetVirtualKeyboardMode(params->mode)) {
 130       error_ = kVirtualKeyboardNotEnabled;
 131       return false;
 132     } else {
 133       return true;
 134     }
 135   }
 136   error_ = kNotYetImplementedError;
 137   return false;
 138 }
 139
 140 bool VirtualKeyboardPrivateSetKeyboardStateFunction::RunSync() {
 141   VirtualKeyboardDelegate* delegate = GetDelegate(this);
 142   if (delegate) {
 143     scoped_ptr<SetRequestedKeyboardState::Params> params =
 144         SetRequestedKeyboardState::Params::Create(*args_);
 145     EXTENSION_FUNCTION_VALIDATE(params);
 146     if (!delegate->SetRequestedKeyboardState(params->state)) {
 147       error_ = kVirtualKeyboardNotEnabled;
 148       return false;
 149     } else {
 150       return true;
 151     }
 152   }
 153   error_ = kNotYetImplementedError;
 154   return false;
 155 }
 156
 157 VirtualKeyboardAPI::VirtualKeyboardAPI(content::BrowserContext* context) {
 158   delegate_ =
 159       extensions::ExtensionsAPIClient::Get()->CreateVirtualKeyboardDelegate();
 160 }
 161
 162 VirtualKeyboardAPI::~VirtualKeyboardAPI() {
 163 }
 164
 165 static base::LazyInstance<BrowserContextKeyedAPIFactory<VirtualKeyboardAPI>>
 166     g_factory = LAZY_INSTANCE_INITIALIZER;
 167
 168 // static
 169 BrowserContextKeyedAPIFactory<VirtualKeyboardAPI>*
 170 VirtualKeyboardAPI::GetFactoryInstance() {
 171   return g_factory.Pointer();
 172 }
 173
 174 }  // namespace extensions