weex_core/Source/android/jsengine/bridge/platform/platform_side_multi_process.cpp

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
//
// Created by yxp on 2018/6/15.
//

#include "platform_side_multi_process.h"

#include "android/jsengine/weex_ipc_server.h"
#include "core/layout/layout.h"
#include "third_party/IPC/Buffering/IPCBuffer.h"
#include "third_party/IPC/IPCResult.h"
#include "third_party/IPC/IPCSender.h"
#include "third_party/IPC/Serializing/IPCSerializer.h"
#include "third_party/IPC/IPCMessageJS.h"
#include "wson/wson.h"

namespace weex {

inline static void wson_push_type_char_array(wson_buffer *buffer,
                                             const char *src, int32_t length) {
  wson_push_type_uint8_string(buffer, (const uint8_t *)src, length);
}

WXCoreSize PlatformSideInMultiProcess::InvokeMeasureFunction(
    const char *page_id, long render_ptr, float width, int width_measure_mode,
    float height, int height_measure_mode) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::INVOKE_MEASURE_FUNCTION));
  serializer->add(page_id, strlen(page_id));
  serializer->add(static_cast<int64_t>(render_ptr));
  serializer->add(width);
  serializer->add(width_measure_mode);
  serializer->add(height);
  serializer->add(height_measure_mode);
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());

  const char *result_str = result->getByteArrayContent();
  WXCoreSize size;
  size.width = reinterpret_cast<const float *>(result_str)[0];
  size.height = reinterpret_cast<const float *>(result_str)[1];
  return size;
}
void PlatformSideInMultiProcess::InvokeLayoutBefore(const char *page_id,
                                                    long render_ptr) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::INVOKE_LAYOUT_BEFORE));
  serializer->add(page_id, strlen(page_id));
  serializer->add(static_cast<int64_t>(render_ptr));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}
void PlatformSideInMultiProcess::InvokeLayoutAfter(const char *page_id,
                                                   long render_ptr, float width,
                                                   float height) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::INVOKE_LAYOUT_AFTER));
  serializer->add(page_id, strlen(page_id));
  serializer->add(static_cast<int64_t>(render_ptr));
  serializer->add(width);
  serializer->add(height);
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

void PlatformSideInMultiProcess::SetJSVersion(const char *version) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::SET_JS_VERSION));
  serializer->add(version, strlen(version));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

void PlatformSideInMultiProcess::ReportException(const char *page_id,
                                                 const char *func,
                                                 const char *exception_string) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::REPORT_EXCEPTION));
  serializer->add(page_id, strlen(page_id));
  serializer->add(func, strlen(func));
  serializer->add(exception_string, strlen(exception_string));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

void PlatformSideInMultiProcess::ReportServerCrash(const char *instance_id) {
  // TODO
}

void PlatformSideInMultiProcess::ReportNativeInitStatus(const char *status_code,
                                         const char *error_msg) {
  // TODO
}

int PlatformSideInMultiProcess::CallNative(const char *page_id,
                                           const char *task,
                                           const char *callback) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::CALL_NATIVE));
  serializer->add(page_id, strlen(page_id));
  serializer->add(task, strlen(task));
  serializer->add(callback, strlen(callback));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

std::unique_ptr<IPCResult> PlatformSideInMultiProcess::CallNativeModule(
    const char *page_id, const char *module, const char *method,
    const char *arguments, int arguments_length, const char *options,
    int options_length) {
  LOGE("CallNativeModule ipc");
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::CALL_NATIVE_MODULE));
  serializer->add(page_id, strlen(page_id));
  // module args[1]
  serializer->add(module, strlen(module));
  // method args[2]
  serializer->add(method, strlen(method));
  // arguments args[3]
  serializer->add(arguments, arguments_length);
  // options args[4]
  serializer->add(options, options_length);
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result;
}

void PlatformSideInMultiProcess::CallNativeComponent(
    const char *page_id, const char *ref, const char *method,
    const char *arguments, int arguments_length, const char *options,
    int options_length) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::CALL_NATIVE_COMPONENT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  serializer->add(method, strlen(method));
  serializer->add(arguments, arguments_length);
  serializer->add(arguments_length);
  serializer->add(options, options_length);
  serializer->add(options_length);
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

void PlatformSideInMultiProcess::SetTimeout(const char *callback_id,
                                            const char *time) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::SET_TIMEOUT));
  serializer->add(callback_id, strlen(callback_id));
  serializer->add(time, strlen(time));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

void PlatformSideInMultiProcess::NativeLog(const char *str_array) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::NATIVE_LOG));
  serializer->add(str_array, strlen(str_array));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

int PlatformSideInMultiProcess::UpdateFinish(const char *page_id,
                                             const char *task, int taskLen,
                                             const char *callback, int callbackLen) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::UPDATE_FINISH));
  serializer->add(page_id, strlen(page_id));
  serializer->add(task, strlen(task));
  serializer->add(callback, strlen(callback));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::RefreshFinish(const char *page_id,
                                              const char *task,
                                              const char *callback) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::REFRESH_FINISH));
  serializer->add(page_id, strlen(page_id));
  serializer->add(task, strlen(task));
  serializer->add(callback, strlen(callback));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::AddEvent(const char *page_id, const char *ref,
                                         const char *event) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::ADD_EVENT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  serializer->add(event, strlen(event));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::RemoveEvent(const char *page_id,
                                            const char *ref,
                                            const char *event) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::REMOVE_EVENT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  serializer->add(event, strlen(event));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::CreateBody(
    const char *page_id, const char *component_type, const char *ref,
    std::map<std::string, std::string> *styles,
    std::map<std::string, std::string> *attributes,
    std::set<std::string> *events, const WXCoreMargin &margins,
    const WXCorePadding &paddings, const WXCoreBorderWidth &borders) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::CREATE_BODY));
  serializer->add(page_id, strlen(page_id));
  serializer->add(component_type, strlen(component_type));
  serializer->add(ref, strlen(ref));

  if (styles != nullptr) {
    wson_buffer *styles_buffer = wson_buffer_new();
    wson_push_type_map(styles_buffer, styles->size());
    for (auto it = styles->begin(); it != styles->end(); ++it) {
      wson_push_type_char_array(styles_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(styles_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(styles_buffer->data),
                    styles_buffer->position);
    wson_buffer_free(styles_buffer);
  } else {
    serializer->addVoid();
  }

  if (attributes != nullptr) {
    wson_buffer *attrs_buffer = wson_buffer_new();
    wson_push_type_map(attrs_buffer, attributes->size());
    for (auto it = attributes->begin(); it != attributes->end(); ++it) {
      wson_push_type_char_array(attrs_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(attrs_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(attrs_buffer->data),
                    attrs_buffer->position);
    wson_buffer_free(attrs_buffer);
  } else {
    serializer->addVoid();
  }

  if (events != nullptr) {
    wson_buffer *events_buffer = wson_buffer_new();
    wson_push_type_array(events_buffer, events->size());
    for (auto it = events->begin(); it != events->end(); ++it) {
      wson_push_type_char_array(events_buffer, (*it).c_str(), (*it).size());
    }
    serializer->add(static_cast<char *>(events_buffer->data),
                    events_buffer->position);
    wson_buffer_free(events_buffer);
  } else {
    serializer->addVoid();
  }

  float margins_buffer[]{
      margins.getMargin(kMarginTop), margins.getMargin(kMarginBottom),
      margins.getMargin(kMarginLeft), margins.getMargin(kMarginRight)};
  serializer->add(reinterpret_cast<uint16_t *>(margins_buffer),
                  4 * sizeof(float));
  float paddings_buffer[]{
      paddings.getPadding(kPaddingTop), paddings.getPadding(kPaddingBottom),
      paddings.getPadding(kPaddingLeft), paddings.getPadding(kPaddingRight)};
  serializer->add(reinterpret_cast<uint16_t *>(paddings_buffer),
                  4 * sizeof(float));
  float borders_buffer[]{borders.getBorderWidth(kBorderWidthTop),
                         borders.getBorderWidth(kBorderWidthBottom),
                         borders.getBorderWidth(kBorderWidthLeft),
                         borders.getBorderWidth(kBorderWidthRight)};
  serializer->add(reinterpret_cast<uint16_t *>(borders_buffer),
                  4 * sizeof(float));

  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());

  return result->get<int>();
}

int PlatformSideInMultiProcess::AddElement(
    const char *page_id, const char *component_type, const char *ref,
    int &index, const char *parentRef,
    std::map<std::string, std::string> *styles,
    std::map<std::string, std::string> *attributes,
    std::set<std::string> *events, const WXCoreMargin &margins,
    const WXCorePadding &paddings, const WXCoreBorderWidth &borders,
    bool willLayout) {

  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::ADD_ELEMENT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(component_type, strlen(component_type));
  serializer->add(ref, strlen(ref));
  serializer->add(index);
  serializer->add(parentRef, strlen(parentRef));

  if (styles != nullptr) {
    wson_buffer *styles_buffer = wson_buffer_new();
    wson_push_type_map(styles_buffer, styles->size());
    for (auto it = styles->begin(); it != styles->end(); ++it) {
      wson_push_type_char_array(styles_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(styles_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(styles_buffer->data),
                    styles_buffer->position);
    wson_buffer_free(styles_buffer);
  } else {
    serializer->addVoid();
  }

  if (attributes != nullptr) {
    wson_buffer *attrs_buffer = wson_buffer_new();
    wson_push_type_map(attrs_buffer, attributes->size());
    for (auto it = attributes->begin(); it != attributes->end(); ++it) {
      wson_push_type_char_array(attrs_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(attrs_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(attrs_buffer->data),
                    attrs_buffer->position);
    wson_buffer_free(attrs_buffer);
  } else {
    serializer->addVoid();
  }

  if (events != nullptr) {
    wson_buffer *events_buffer = wson_buffer_new();
    wson_push_type_array(events_buffer, events->size());
    for (auto it = events->begin(); it != events->end(); ++it) {
      wson_push_type_char_array(events_buffer, (*it).c_str(), (*it).size());
    }
    serializer->add(static_cast<char *>(events_buffer->data),
                    events_buffer->position);
    wson_buffer_free(events_buffer);
  } else {
    serializer->addVoid();
  }

  float margins_buffer[]{
      margins.getMargin(kMarginTop), margins.getMargin(kMarginBottom),
      margins.getMargin(kMarginLeft), margins.getMargin(kMarginRight)};
  serializer->add(reinterpret_cast<const char *>(margins_buffer),
                  4 * sizeof(float));
  float paddings_buffer[]{
      paddings.getPadding(kPaddingTop), paddings.getPadding(kPaddingBottom),
      paddings.getPadding(kPaddingLeft), paddings.getPadding(kPaddingRight)};
  serializer->add(reinterpret_cast<const char *>(paddings_buffer),
                  4 * sizeof(float));
  float borders_buffer[]{borders.getBorderWidth(kBorderWidthTop),
                         borders.getBorderWidth(kBorderWidthBottom),
                         borders.getBorderWidth(kBorderWidthLeft),
                         borders.getBorderWidth(kBorderWidthRight)};
  serializer->add(reinterpret_cast<const char *>(borders_buffer),
                  4 * sizeof(float));
  serializer->add(willLayout);

  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());

  return result->get<int>();
}

int PlatformSideInMultiProcess::Layout(const char *page_id, const char *ref,
                                       int top, int bottom, int left, int right,
                                       int height, int width, bool isRTL,
                                       int index) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(static_cast<uint32_t>(IPCMsgFromCoreToPlatform::LAYOUT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  serializer->add(top);
  serializer->add(bottom);
  serializer->add(left);
  serializer->add(right);
  serializer->add(height);
  serializer->add(width);
  serializer->add(isRTL);
  serializer->add(index);
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::UpdateStyle(
    const char *page_id, const char *ref,
    std::vector<std::pair<std::string, std::string>> *style,
    std::vector<std::pair<std::string, std::string>> *margin,
    std::vector<std::pair<std::string, std::string>> *padding,
    std::vector<std::pair<std::string, std::string>> *border) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::UPDATE_STYLE));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));

  if (style != nullptr) {
    wson_buffer *style_buffer = wson_buffer_new();
    wson_push_type_map(style_buffer, style->size());
    for (auto it = style->begin(); it != style->end(); ++it) {
      wson_push_type_char_array(style_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(style_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(style_buffer->data),
                    style_buffer->position);
    wson_buffer_free(style_buffer);
  } else {
    serializer->addVoid();
  }

  if (margin != nullptr) {
    wson_buffer *margin_buffer = wson_buffer_new();
    wson_push_type_map(margin_buffer, margin->size());
    for (auto it = margin->begin(); it != margin->end(); ++it) {
      wson_push_type_char_array(margin_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(margin_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(margin_buffer->data),
                    margin_buffer->position);
    wson_buffer_free(margin_buffer);
  } else {
    serializer->addVoid();
  }

  if (padding != nullptr) {
    wson_buffer *padding_buffer = wson_buffer_new();
    wson_push_type_map(padding_buffer, padding->size());
    for (auto it = padding->begin(); it != padding->end(); ++it) {
      wson_push_type_char_array(padding_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(padding_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(padding_buffer->data),
                    padding_buffer->position);
    wson_buffer_free(padding_buffer);
  } else {
    serializer->addVoid();
  }

  if (border != nullptr) {
    wson_buffer *border_buffer = wson_buffer_new();
    wson_push_type_map(border_buffer, border->size());
    for (auto it = border->begin(); it != border->end(); ++it) {
      wson_push_type_char_array(border_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(border_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(border_buffer->data),
                    border_buffer->position);
    wson_buffer_free(border_buffer);
  } else {
    serializer->addVoid();
  }

  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());

  return result->get<int>();
}

int PlatformSideInMultiProcess::UpdateAttr(
    const char *page_id, const char *ref,
    std::vector<std::pair<std::string, std::string>> *attrs) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::UPDATE_ATTR));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));

  if (attrs != nullptr) {
    wson_buffer *attrs_buffer = wson_buffer_new();
    wson_push_type_map(attrs_buffer, attrs->size());
    for (auto it = attrs->begin(); it != attrs->end(); ++it) {
      wson_push_type_char_array(attrs_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(attrs_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(attrs_buffer->data),
                    attrs_buffer->position);
    wson_buffer_free(attrs_buffer);
  } else {
    serializer->addVoid();
  }

  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());

  return result->get<int>();
}

int PlatformSideInMultiProcess::CreateFinish(const char *page_id) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::CREATE_FINISH));
  serializer->add(page_id, strlen(page_id));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::RenderSuccess(const char *page_id) {
  WeexIPCClient *pClient = client_;

  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::RENDER_SUCCESS));
  serializer->add(page_id, strlen(page_id));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::RemoveElement(const char *page_id,
                                              const char *ref) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::REMOVE_ELEMENT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::MoveElement(const char *page_id,
                                            const char *ref,
                                            const char *parent_ref, int index) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::MOVE_ELEMENT));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  serializer->add(parent_ref, strlen(parent_ref));
  serializer->add(index);
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}

int PlatformSideInMultiProcess::AppendTreeCreateFinish(const char *page_id,
                                                       const char *ref) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(static_cast<uint32_t>(
      IPCMsgFromCoreToPlatform::APPEND_TREE_CREATE_FINISH));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
  return result->get<int>();
}
void PlatformSideInMultiProcess::SetPageDirty(const char *page_id, bool dirty) {
//do Nothing
}

int PlatformSideInMultiProcess::HasTransitionPros(
    const char *page_id, const char *ref,
    std::vector<std::pair<std::string, std::string>> *style) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::HAS_TRANSITION_PROS));
  serializer->add(page_id, strlen(page_id));
  serializer->add(ref, strlen(ref));

  if (style != nullptr) {
    wson_buffer *style_buffer = wson_buffer_new();
    wson_push_type_map(style_buffer, style->size());
    auto it = style->begin();
    for (; it != style->end(); ++it) {
      wson_push_type_char_array(style_buffer, it->first.c_str(),
                                it->first.size());
      wson_push_type_char_array(style_buffer, it->second.c_str(),
                                it->second.size());
    }
    serializer->add(static_cast<char *>(style_buffer->data),
                    style_buffer->position);
    wson_buffer_free(style_buffer);
  } else {
    serializer->addVoid();
  }

  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());

  return result->get<int>();
}

void PlatformSideInMultiProcess::PostMessage(const char *vm_id,
                                             const char *data) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::POST_MESSAGE));
  serializer->add(vm_id, strlen(vm_id));
  serializer->add(data, strlen(data));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}

void PlatformSideInMultiProcess::DispatchMessage(const char *client_id,
                                                 const char *vm_id,
                                                 const char *data,
                                                 const char *callback) {
  WeexIPCClient *pClient = client_;
  
  IPCSender *sender = pClient->getSender();
  std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
  serializer->setMsg(
      static_cast<uint32_t>(IPCMsgFromCoreToPlatform::DISPATCH_MESSAGE));
  serializer->add(client_id, strlen(client_id));
  serializer->add(vm_id, strlen(vm_id));
  serializer->add(data, strlen(data));
  serializer->add(callback, strlen(callback));
  std::unique_ptr<IPCBuffer> buffer = serializer->finish();
  std::unique_ptr<IPCResult> result = sender->send(buffer.get());
}
}  // namespace weex