src/extension/extension_adapter.cc

   1 // Copyright 2015 Samsung Electronics Co, Ltd. 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 "extension/extension_adapter.h"
   6
   7 #include <string>
   8
   9 #include "common/logger.h"
  10
  11 namespace wrt {
  12
  13 ExtensionAdapter::ExtensionAdapter()
  14   : next_xw_extension_(1),
  15     next_xw_instance_(1) {
  16 }
  17
  18 ExtensionAdapter::~ExtensionAdapter() {
  19 }
  20
  21 ExtensionAdapter* ExtensionAdapter::GetInstance() {
  22   static ExtensionAdapter self;
  23   return &self;
  24 }
  25
  26 XW_Extension ExtensionAdapter::GetNextXWExtension() {
  27   return next_xw_extension_++;
  28 }
  29
  30 XW_Instance ExtensionAdapter::GetNextXWInstance() {
  31   return next_xw_instance_++;
  32 }
  33
  34 void ExtensionAdapter::RegisterExtension(Extension* extension) {
  35   XW_Extension xw_extension = extension->xw_extension_;
  36   if (!(xw_extension > 0 && xw_extension < next_xw_extension_)) {
  37     LOGGER(WARN) << "xw_extension (" << xw_extension << ") is invalid.";
  38     return;
  39   }
  40   if (extension_map_.find(xw_extension) == extension_map_.end())
  41     extension_map_[xw_extension] = extension;
  42 }
  43
  44 void ExtensionAdapter::UnregisterExtension(Extension* extension) {
  45   XW_Extension xw_extension = extension->xw_extension_;
  46   if (!(xw_extension > 0 && xw_extension < next_xw_extension_)) {
  47     LOGGER(WARN) << "xw_extension (" << xw_extension << ") is invalid.";
  48     return;
  49   }
  50   if (extension_map_.find(xw_extension) != extension_map_.end())
  51     extension_map_.erase(xw_extension);
  52 }
  53
  54 void ExtensionAdapter::RegisterInstance(ExtensionInstance* instance) {
  55   XW_Instance xw_instance = instance->xw_instance_;
  56   if (!(xw_instance > 0 && xw_instance < next_xw_instance_)) {
  57     LOGGER(WARN) << "xw_instance (" << xw_instance << ") is invalid.";
  58     return;
  59   }
  60   if (instance_map_.find(xw_instance) == instance_map_.end())
  61     instance_map_[xw_instance] = instance;
  62 }
  63
  64 void ExtensionAdapter::UnregisterInstance(ExtensionInstance* instance) {
  65   XW_Instance xw_instance = instance->xw_instance_;
  66   if (!(xw_instance > 0 && xw_instance < next_xw_instance_)) {
  67     LOGGER(WARN) << "xw_instance (" << xw_instance << ") is invalid.";
  68     return;
  69   }
  70   if (instance_map_.find(xw_instance) != instance_map_.end())
  71     instance_map_.erase(xw_instance);
  72 }
  73
  74 const void* ExtensionAdapter::GetInterface(const char* name) {
  75   if (!strcmp(name, XW_CORE_INTERFACE_1)) {
  76     static const XW_CoreInterface_1 coreInterface1 = {
  77       CoreSetExtensionName,
  78       CoreSetJavaScriptAPI,
  79       CoreRegisterInstanceCallbacks,
  80       CoreRegisterShutdownCallback,
  81       CoreSetInstanceData,
  82       CoreGetInstanceData
  83     };
  84     return &coreInterface1;
  85   }
  86
  87   if (!strcmp(name, XW_MESSAGING_INTERFACE_1)) {
  88     static const XW_MessagingInterface_1 messagingInterface1 = {
  89       MessagingRegister,
  90       MessagingPostMessage
  91     };
  92     return &messagingInterface1;
  93   }
  94
  95   if (!strcmp(name, XW_INTERNAL_SYNC_MESSAGING_INTERFACE_1)) {
  96     static const XW_Internal_SyncMessagingInterface_1
  97         syncMessagingInterface1 = {
  98       SyncMessagingRegister,
  99       SyncMessagingSetSyncReply
 100     };
 101     return &syncMessagingInterface1;
 102   }
 103
 104   if (!strcmp(name, XW_INTERNAL_ENTRY_POINTS_INTERFACE_1)) {
 105     static const XW_Internal_EntryPointsInterface_1 entryPointsInterface1 = {
 106       EntryPointsSetExtraJSEntryPoints
 107     };
 108     return &entryPointsInterface1;
 109   }
 110
 111   if (!strcmp(name, XW_INTERNAL_RUNTIME_INTERFACE_1)) {
 112     static const XW_Internal_RuntimeInterface_1 runtimeInterface1 = {
 113       RuntimeGetStringVariable
 114     };
 115     return &runtimeInterface1;
 116   }
 117
 118   if (!strcmp(name, XW_INTERNAL_PERMISSIONS_INTERFACE_1)) {
 119     static const XW_Internal_PermissionsInterface_1 permissionsInterface1 = {
 120       PermissionsCheckAPIAccessControl,
 121       PermissionsRegisterPermissions
 122     };
 123     return &permissionsInterface1;
 124   }
 125
 126   LOGGER(WARN) << "Interface '" << name << "' is not supported.";
 127   return NULL;
 128 }
 129
 130 Extension* ExtensionAdapter::GetExtension(XW_Extension xw_extension) {
 131   ExtensionAdapter* adapter = ExtensionAdapter::GetInstance();
 132   ExtensionMap::iterator it = adapter->extension_map_.find(xw_extension);
 133   if (it == adapter->extension_map_.end())
 134     return NULL;
 135   return it->second;
 136 }
 137
 138 ExtensionInstance* ExtensionAdapter::GetExtensionInstance(
 139     XW_Instance xw_instance) {
 140   ExtensionAdapter* adapter = ExtensionAdapter::GetInstance();
 141   InstanceMap::iterator it = adapter->instance_map_.find(xw_instance);
 142   if (it == adapter->instance_map_.end())
 143     return NULL;
 144   return it->second;
 145 }
 146
 147 #define CHECK(x, xw) \
 148   if (!x) { \
 149     LOGGER(WARN) << "Ignoring call. Invalid " << #xw << " = " << xw; \
 150     return; \
 151   }
 152
 153 #define RETURN_IF_INITIALIZED(x) \
 154   if (x->initialized_) \
 155     return;
 156
 157 void ExtensionAdapter::CoreSetExtensionName(XW_Extension xw_extension,
 158     const char* name) {
 159   Extension* extension = GetExtension(xw_extension);
 160   CHECK(extension, xw_extension);
 161   RETURN_IF_INITIALIZED(extension);
 162   extension->name_ = name;
 163 }
 164
 165 void ExtensionAdapter::CoreSetJavaScriptAPI(XW_Extension xw_extension,
 166     const char* javascript_api) {
 167   Extension* extension = GetExtension(xw_extension);
 168   CHECK(extension, xw_extension);
 169   RETURN_IF_INITIALIZED(extension);
 170   extension->javascript_api_ = javascript_api;
 171 }
 172
 173 void ExtensionAdapter::CoreRegisterInstanceCallbacks(XW_Extension xw_extension,
 174     XW_CreatedInstanceCallback created,
 175     XW_DestroyedInstanceCallback destroyed) {
 176   Extension* extension = GetExtension(xw_extension);
 177   CHECK(extension, xw_extension);
 178   RETURN_IF_INITIALIZED(extension);
 179   extension->created_instance_callback_ = created;
 180   extension->destroyed_instance_callback_ = destroyed;
 181 }
 182
 183 void ExtensionAdapter::CoreRegisterShutdownCallback(XW_Extension xw_extension,
 184     XW_ShutdownCallback shutdown) {
 185   Extension* extension = GetExtension(xw_extension);
 186   CHECK(extension, xw_extension);
 187   RETURN_IF_INITIALIZED(extension);
 188   extension->shutdown_callback_ = shutdown;
 189 }
 190
 191 void ExtensionAdapter::CoreSetInstanceData(XW_Instance xw_instance,
 192     void* data) {
 193   ExtensionInstance* instance = GetExtensionInstance(xw_instance);
 194   CHECK(instance, xw_instance);
 195   instance->instance_data_ = data;
 196 }
 197
 198 void* ExtensionAdapter::CoreGetInstanceData(XW_Instance xw_instance) {
 199   ExtensionInstance* instance = GetExtensionInstance(xw_instance);
 200   if (instance)
 201     return instance->instance_data_;
 202   else
 203     return NULL;
 204 }
 205
 206 void ExtensionAdapter::MessagingRegister(XW_Extension xw_extension,
 207     XW_HandleMessageCallback handle_message) {
 208   Extension* extension = GetExtension(xw_extension);
 209   CHECK(extension, xw_extension);
 210   RETURN_IF_INITIALIZED(extension);
 211   extension->handle_msg_callback_ = handle_message;
 212 }
 213
 214 void ExtensionAdapter::MessagingPostMessage(XW_Instance xw_instance,
 215     const char* message) {
 216   ExtensionInstance* instance = GetExtensionInstance(xw_instance);
 217   CHECK(instance, xw_instance);
 218   instance->PostMessageToJS(message);
 219 }
 220
 221 void ExtensionAdapter::SyncMessagingRegister(XW_Extension xw_extension,
 222     XW_HandleSyncMessageCallback handle_sync_message) {
 223   Extension* extension = GetExtension(xw_extension);
 224   CHECK(extension, xw_extension);
 225   RETURN_IF_INITIALIZED(extension);
 226   extension->handle_sync_msg_callback_ = handle_sync_message;
 227 }
 228
 229 void ExtensionAdapter::SyncMessagingSetSyncReply(XW_Instance xw_instance,
 230     const char* reply) {
 231   ExtensionInstance* instance = GetExtensionInstance(xw_instance);
 232   CHECK(instance, xw_instance);
 233   instance->SyncReplyToJS(reply);
 234 }
 235
 236 void ExtensionAdapter::EntryPointsSetExtraJSEntryPoints(
 237     XW_Extension xw_extension, const char** entry_points) {
 238   Extension* extension = GetExtension(xw_extension);
 239   CHECK(extension, xw_extension);
 240   RETURN_IF_INITIALIZED(extension);
 241
 242   for (int i=0; entry_points[i]; ++i) {
 243     extension->entry_points_.push_back(std::string(entry_points[i]));
 244   }
 245 }
 246
 247 void ExtensionAdapter::RuntimeGetStringVariable(XW_Extension xw_extension,
 248     const char* key,
 249     char* value,
 250     unsigned int value_len) {
 251   Extension* extension = GetExtension(xw_extension);
 252   CHECK(extension, xw_extension);
 253   extension->GetRuntimeVariable(key, value, value_len);
 254 }
 255
 256 int ExtensionAdapter::PermissionsCheckAPIAccessControl(
 257     XW_Extension xw_extension, const char* api_name) {
 258   Extension* extension = GetExtension(xw_extension);
 259   if (extension)
 260     return extension->CheckAPIAccessControl(api_name);
 261   else
 262     return XW_ERROR;
 263 }
 264
 265 int ExtensionAdapter::PermissionsRegisterPermissions(XW_Extension xw_extension,
 266     const char* perm_table) {
 267   Extension* extension = GetExtension(xw_extension);
 268   if (extension)
 269     return extension->RegisterPermissions(perm_table);
 270   else
 271     return XW_ERROR;
 272 }
 273
 274 #undef CHECK
 275 #undef RETURN_IF_INITIALIZED
 276
 277 }  // namespace wrt