src/xwalk-module/xwalk_extension_client.cpp

   1
   2 #include <dlog.h>
   3 #include "xwalk_extension_client.h"
   4
   5 #include "extension_adapter.h"
   6 #include "extension_manager.h"
   7
   8 #define RETURN_IF_NULL(x) \
   9   do { \
  10     if(!x){ \
  11         LOGW("%s is NULL", #x); \
  12     } \
  13   }while(0)
  14
  15 using namespace wrt::xwalk;
  16
  17 namespace wrt {
  18
  19
  20 void XWalkExtensionClient::ListenerAdapter::PostMessageToJS(const std::string& msg){
  21   if (handler_)
  22     handler_->HandleMessageFromNative(msg);
  23 }
  24
  25 void XWalkExtensionClient::ListenerAdapter::PostDataToJS(const std::string& msg, uint8_t* buffer, size_t len) {
  26   if (handler_)
  27     handler_->HandleMessageFromNative(msg, buffer, len);
  28 }
  29
  30 XWalkExtensionClient::XWalkExtensionClient() {
  31 }
  32
  33 XWalkExtensionClient::~XWalkExtensionClient() {
  34   for (auto itr = extension_apis_.begin(); itr != extension_apis_.end(); ++itr) {
  35       delete itr->second;
  36   }
  37 }
  38
  39 XWalkExtensionClient::ExtensionCodePoints::ExtensionCodePoints(
  40     Extension* extension) : extension_(extension) {
  41   entry_points_ = extension->entry_points();
  42 }
  43
  44 XWalkExtensionClient::ExtensionCodePoints::~ExtensionCodePoints() {
  45 }
  46
  47 std::string XWalkExtensionClient::ExtensionCodePoints::api() {
  48   return extension_->javascript_api();
  49 }
  50
  51 int64_t XWalkExtensionClient::CreateInstance(const std::string& extension_name, InstanceHandler* handler) {
  52     LOGD("Extension CreateInstance: [%s]", extension_name.c_str());
  53
  54     ExtensionMap& map = ExtensionManager::GetInstance()->extensions();
  55     if (map.find(extension_name) == map.end()) {
  56         LOGE("Can't find extension name %s", extension_name.c_str());
  57         return 0;
  58     }
  59
  60     Extension* extention = map[extension_name];
  61     ExtensionInstance *instance = extention->CreateInstance();
  62     std::shared_ptr<ListenerAdapter> listener(new ListenerAdapter(handler));
  63     instance->set_post_message_listener(listener.get());
  64     instance->set_post_data_listener(listener.get());
  65
  66     ExtensionAdapter::GetInstance()->RegisterInstance(instance);
  67     int64_t instance_id = instance->xw_instance();
  68     listeners_[instance_id] = listener;
  69     return instance_id;
  70 }
  71
  72 void XWalkExtensionClient::DestroyInstance(int64_t instance_id) {
  73     ExtensionInstance* instance = ExtensionAdapter::GetExtensionInstance(instance_id);
  74     RETURN_IF_NULL(instance);
  75     listeners_[instance_id].reset();
  76     listeners_.erase(instance_id);
  77     delete instance;
  78 }
  79
  80 void XWalkExtensionClient::PostMessageToNative(int64_t instance_id, const std::string& msg) {
  81     ExtensionInstance* instance = ExtensionAdapter::GetExtensionInstance(instance_id);
  82     RETURN_IF_NULL(instance);
  83     instance->HandleMessage(msg);
  84 }
  85
  86 void XWalkExtensionClient::PostMessageToNative(int64_t instance_id, const std::string& msg, unsigned char* buffer, std::size_t len) {
  87     ExtensionInstance* instance = ExtensionAdapter::GetExtensionInstance(instance_id);
  88     RETURN_IF_NULL(instance);
  89     instance->HandleData(msg, buffer, len);
  90 }
  91
  92 std::string XWalkExtensionClient::SendSyncMessageToNative(int64_t instance_id, const std::string& msg) {
  93     ExtensionInstance* instance = ExtensionAdapter::GetExtensionInstance(instance_id);
  94     RETURN_IF_NULL(instance);
  95     instance->HandleSyncMessage(msg);
  96     return instance->sync_replay_msg();
  97 }
  98
  99 std::string XWalkExtensionClient::SendSyncMessageToNative(int64_t instance_id,
 100                                                           const std::string& msg,
 101                                                           unsigned char* buffer,
 102                                                           std::size_t len,
 103                                                           unsigned char** outbuffer,
 104                                                           std::size_t* outlen) {
 105     ExtensionInstance* instance = ExtensionAdapter::GetExtensionInstance(instance_id);
 106     RETURN_IF_NULL(instance);
 107     instance->HandleSyncData(msg, buffer, len);
 108     return instance->sync_data_reply_msg(outbuffer, outlen);
 109 }
 110
 111
 112 void XWalkExtensionClient::Initialize() {
 113     LOGD("========== << Initialize >> ENTER ==========");
 114     extension_apis_.clear();
 115     ExtensionManager::GetInstance()->RegisterExtensionsByMetadata(this);
 116     ExtensionMap& map = ExtensionManager::GetInstance()->extensions();
 117     for (auto itr = map.begin(); itr != map.end(); ++itr) {
 118         std::string name = itr->first;
 119         Extension* extension = itr->second;
 120         ExtensionCodePoints* code = new ExtensionCodePoints(extension);
 121         extension_apis_.insert(std::make_pair(name, code));
 122     }
 123     LOGD("========== << Initialize >> END ==========");
 124 }
 125
 126 const std::string XWalkExtensionClient::GetRuntimeVariable(const std::string& key) const{
 127     return rv_map_[key];
 128 }
 129
 130 void XWalkExtensionClient::UpdateRuntimeVariable(const std::string& key, const std::string& value){
 131     rv_map_[key] = value;
 132 }
 133
 134 } // WRT