node-nim 7.8.13-rc.3 → 7.8.13-rc.5

package/just-task.js

@@ -107,20 +107,21 @@ task('install', () => {
         logger.info('[install] Skip downlaod prebuilt libraries.')
         return
     }
-    let target = '5.0.8'
-    let runtime = 'electron'
+    let target = process.env.npm_config_target
+    let runtime = process.env.npm_config_runtime
     const targetPlatform = process.env.npm_config_target_platform || process.platform
     const targetArch = process.env.npm_config_target_arch || process.arch
-    const downloadUrl = process.env.npm_config_download_url
     const curPkgMeta = require(path.join(__dirname, 'package.json'))
     const rootPkgMeta = require(path.join(process.env.INIT_CWD, 'package.json'))
     logger.info('------------------ just install --------------------')
-    if (rootPkgMeta.devDependencies && rootPkgMeta.devDependencies.electron) {
-        // v13.1.2 => 13.1.2, remove prefix 'v'
-        target = rootPkgMeta.devDependencies.electron.replace(/^.*?(\d+.+\d).*/, '$1')
-    } else {
-        target = process.version.match(/^v(\d+\.\d+)/)[1]
-        runtime = 'node'
+    if (!target && !runtime) {
+        if (rootPkgMeta.devDependencies && rootPkgMeta.devDependencies.electron) {
+            // v13.1.2 => 13.1.2, remove prefix 'v'
+            target = rootPkgMeta.devDependencies.electron.replace(/^.*?(\d+.+\d).*/, '$1')
+        } else {
+            target = process.version.match(/^v(\d+\.\d+)/)[1]
+            runtime = 'node'
+        }
     }
     // 13.1.2 => 13.1, match major.minor only
     const nodeAbi = `${runtime}-v${target.replace(/^(\d+.+?\d+).*/, '$1')}`
@@ -147,12 +148,16 @@ task('install', () => {
                 const cachePath = path.join(__dirname, 'nim_sdk')
                 const temporaryPath = path.join(__dirname, 'temporary')
                 fetchWrapper({
+                    platform: targetPlatform,
+                    arch: targetArch,
                     fetchUrl: nativeUrl,
                     temporaryPath,
                     extractPath: cachePath
                 })
                     .then(() => {
                         return buildWrapper({
+                            platform: targetPlatform,
+                            arch: targetArch,
                             sourcePath: cachePath
                         })
                     })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-nim",
-    "version": "7.8.13-rc.3",
+    "version": "7.8.13-rc.5",
     "description": "NetEase IM nodejs wrapper based on NetEase IM C++ SDK",
     "main": "js/nim.js",
     "types": "types/nim.d.ts",
@@ -45,6 +45,7 @@
         "js",
         "scripts",
         "just-task.js",
-        "binding.gyp"
+        "binding.gyp",
+        "src"
     ]
 }

package/src/api/nim_node_client.cpp

@@ -0,0 +1,282 @@
+#include "nim_node_client.h"
+#include <node_object_wrap.h>
+#include "../helper/nim_node_client_helper.h"
+#include "nim_cpp_wrapper/api/nim_cpp_client.h"
+#include "nim_node_client_event_handler.h"
+#include "nim_node_helper.h"
+
+namespace nim_node {
+DEFINE_CLASS(Client);
+
+Client::Client(Isolate* isolate) {
+    isolate_ = isolate;
+}
+Client::~Client() {}
+void Client::InitModule(Local<Object>& module) {
+    BEGIN_OBJECT_INIT(Client, New, 5)
+
+    SET_PROTOTYPE(Init)
+    SET_PROTOTYPE(GetSDKConfig)
+    SET_PROTOTYPE(CleanUp)
+    SET_PROTOTYPE(CleanUp2)
+    SET_PROTOTYPE(LoginCustomDataToJson)
+    SET_PROTOTYPE(Login)
+    SET_PROTOTYPE(GetLoginState)
+    SET_PROTOTYPE(Relogin)
+    SET_PROTOTYPE(Logout)
+    SET_PROTOTYPE(KickOtherClient)
+    SET_PROTOTYPE(RegReloginCb)
+    SET_PROTOTYPE(RegKickoutCb)
+    SET_PROTOTYPE(RegDisconnectCb)
+    SET_PROTOTYPE(RegMultispotLoginCb)
+    SET_PROTOTYPE(RegKickOtherClientCb)
+    SET_PROTOTYPE(RegSyncMultiportPushConfigCb)
+    SET_PROTOTYPE(SetMultiportPushConfigAsync)
+    SET_PROTOTYPE(GetMultiportPushConfigAsync)
+    SET_PROTOTYPE(GetSDKVersion)
+    SET_PROTOTYPE(GetServerCurrentTime)
+    SET_PROTOTYPE(GetCurrentUserAccount)
+    SET_PROTOTYPE(UnregClientCb)
+    END_OBJECT_INIT(Client)
+}
+
+void Client::New(const FunctionCallbackInfo<Value>& args) {
+    Isolate* isolate = args.GetIsolate();
+    if (args.IsConstructCall()) {
+        Client* client = new Client(isolate);
+        client->Wrap(args.This());
+        args.GetReturnValue().Set(args.This());
+    } else {
+        Local<Function> cons = Local<Function>::New(isolate, constructor);
+        Local<Context> context = isolate->GetCurrentContext();
+        Local<Object> instance = cons->NewInstance(context).ToLocalChecked();
+        args.GetReturnValue().Set(instance);
+    }
+}
+
+NIM_SDK_NODE_API_DEF(Client, Init) {
+    CHECK_API_FUNC(Client, 4)
+    UTF8String appkey, appdata_path, app_install_path;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, appkey)
+    GET_ARGS_VALUE(isolate, 1, utf8string, appdata_path)
+    GET_ARGS_VALUE(isolate, 2, utf8string, app_install_path)
+    nim::SDKConfig config;
+    status = nim_client_config_obj_to_struct(isolate, args[3]->ToObject(isolate->GetCurrentContext()).ToLocalChecked(), config);
+    if (status != napi_ok) {
+    }
+    bool ret = nim::Client::Init(appkey.toUtf8String(), appdata_path.toUtf8String(), app_install_path.toUtf8String(), config);
+    args.GetReturnValue().Set(Integer::New(args.GetIsolate(), ret ? 1 : 0));
+}
+
+NIM_SDK_NODE_API_DEF(Client, GetSDKConfig) {
+    CHECK_API_FUNC(Client, 0)
+
+    nim::SDKConfig config = nim::Client::GetSDKConfig();
+    Local<Object> config_obj = Object::New(isolate);
+    nim_client_config_to_obj(isolate, config, config_obj);
+    args.GetReturnValue().Set(config_obj);
+}
+NIM_SDK_NODE_API_DEF(Client, CleanUp) {
+    CHECK_API_FUNC(Client, 1)
+
+    UTF8String ext;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, ext)
+
+    nim::Client::Cleanup(ext.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, CleanUp2) {
+    CHECK_API_FUNC(Client, 1)
+
+    UTF8String ext;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, ext)
+
+    nim::Client::Cleanup2(ext.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, LoginCustomDataToJson) {
+    CHECK_API_FUNC(Client, 1)
+
+    UTF8String custom_data;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, custom_data)
+
+    utf8_string jsonValue;
+    nim::Client::LoginCustomDataToJson(custom_data.toUtf8String(), jsonValue);
+
+    args.GetReturnValue().Set(String::NewFromUtf8(isolate, jsonValue.c_str(), NewStringType::kInternalized).ToLocalChecked());
+}
+NIM_SDK_NODE_API_DEF(Client, Login) {
+    CHECK_API_FUNC(Client, 5)
+    UTF8String appkey, account, psw, exten;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, appkey)
+    GET_ARGS_VALUE(isolate, 1, utf8string, account)
+    GET_ARGS_VALUE(isolate, 2, utf8string, psw)
+    GET_ARGS_VALUE(isolate, 4, utf8string, exten)
+    ASSEMBLE_BASE_CALLBACK(3);
+    auto callback = std::bind(&ClientEventHandler::OnLoginCallback, bcb, false, std::placeholders::_1);
+    bool ret = nim::Client::Login(appkey.toUtf8String(), account.toUtf8String(), psw.toUtf8String(), callback);
+
+    args.GetReturnValue().Set(Boolean::New(args.GetIsolate(), ret ? 200 : 0));
+}
+NIM_SDK_NODE_API_DEF(Client, GetLoginState) {
+    CHECK_API_FUNC(Client, 1)
+
+    UTF8String ext;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, ext)
+
+    nim::NIMLoginState state = nim::Client::GetLoginState(ext.toUtf8String());
+    args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, (uint32_t)state));
+}
+NIM_SDK_NODE_API_DEF(Client, Relogin) {
+    CHECK_API_FUNC(Client, 1)
+
+    UTF8String ext;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string, ext)
+
+    nim::Client::Relogin(ext.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, Logout) {
+    CHECK_API_FUNC(Client, 3)
+    uint32_t type;
+    UTF8String exten;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, uint32, type)
+    ASSEMBLE_BASE_CALLBACK(1)
+    GET_ARGS_VALUE(isolate, 2, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnLogoutCallback, bcb, std::placeholders::_1);
+    nim::Client::Logout((nim::NIMLogoutType)(type), callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, KickOtherClient) {
+    CHECK_API_FUNC(Client, 1)
+
+    std::list<utf8_string> others;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, utf8string_list, others)
+
+    nim::Client::KickOtherClient(others);
+}
+NIM_SDK_NODE_API_DEF(Client, RegReloginCb) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    ASSEMBLE_REG_CALLBACK(0, ClientEventHandler, "OnReloginCallback")
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnLoginCallback, nullptr, true, std::placeholders::_1);
+    nim::Client::RegReloginCb(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, RegKickoutCb) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    ASSEMBLE_REG_CALLBACK(0, ClientEventHandler, "OnKickoutCallback")
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnKickoutCallback, std::placeholders::_1);
+    nim::Client::RegKickoutCb(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, RegDisconnectCb) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    ASSEMBLE_REG_CALLBACK(0, ClientEventHandler, "OnDisconnectCallback")
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnDisconnectCallback);
+    nim::Client::RegDisconnectCb(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, RegMultispotLoginCb) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    ASSEMBLE_REG_CALLBACK(0, ClientEventHandler, "OnMultispotLoginCallback")
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnMultispotLoginCallback, std::placeholders::_1);
+    nim::Client::RegMultispotLoginCb(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, RegKickOtherClientCb) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    ASSEMBLE_REG_CALLBACK(0, ClientEventHandler, "OnKickOtherClientCallback")
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnKickOtherClientCallback, std::placeholders::_1);
+    nim::Client::RegKickOtherClientCb(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, RegSyncMultiportPushConfigCb) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    ASSEMBLE_REG_CALLBACK(0, ClientEventHandler, "OnSyncMultiportPushConfigCallback")
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnSyncMultiportPushConfigCallback, nullptr, std::placeholders::_1, std::placeholders::_2);
+    nim::Client::RegSyncMultiportPushConfigCb(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, SetMultiportPushConfigAsync) {
+    CHECK_API_FUNC(Client, 3)
+    bool switch_on;
+    UTF8String exten;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 0, bool, switch_on)
+    ASSEMBLE_BASE_CALLBACK(1)
+    GET_ARGS_VALUE(isolate, 2, utf8string, exten)
+
+    auto callback = std::bind(&ClientEventHandler::OnSyncMultiportPushConfigCallback, bcb, std::placeholders::_1, std::placeholders::_2);
+    nim::Client::SetMultiportPushConfigAsync(switch_on, callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, GetMultiportPushConfigAsync) {
+    CHECK_API_FUNC(Client, 2)
+
+    UTF8String exten;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, utf8string, exten)
+    ASSEMBLE_BASE_CALLBACK(0)
+
+    auto callback = std::bind(&ClientEventHandler::OnSyncMultiportPushConfigCallback, bcb, std::placeholders::_1, std::placeholders::_2);
+    nim::Client::GetMultiportPushConfigAsync(callback, exten.toUtf8String());
+}
+NIM_SDK_NODE_API_DEF(Client, GetSDKVersion) {
+    CHECK_API_FUNC(Client, 0)
+
+    utf8_string version = nim::Client::GetSDKVersion();
+    args.GetReturnValue().Set(nim_napi_new_utf8string(args.GetIsolate(), version.c_str()));
+}
+NIM_SDK_NODE_API_DEF(Client, GetServerCurrentTime) {
+    CHECK_API_FUNC(Client, 2)
+
+    bool calc_local;
+    auto status = napi_ok;
+    GET_ARGS_VALUE(isolate, 1, bool, calc_local)
+    ASSEMBLE_BASE_CALLBACK(0)
+
+    auto callback =
+        std::bind(&ClientEventHandler::OnGetServerCurrentTimeCallback, bcb, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
+    nim::Client::GetServerCurrentTime(callback, calc_local);
+}
+NIM_SDK_NODE_API_DEF(Client, GetCurrentUserAccount) {
+    CHECK_API_FUNC(Client, 0)
+
+    auto accid = nim::Client::GetCurrentUserAccount();
+    args.GetReturnValue().Set(nim_napi_new_utf8string(args.GetIsolate(), accid.c_str()));
+}
+NIM_SDK_NODE_API_DEF(Client, UnregClientCb) {
+    CHECK_API_FUNC(Client, 0)
+    nim::Client::UnregClientCb();
+}
+
+}  // namespace nim_node

package/src/api/nim_node_client.h

@@ -0,0 +1,52 @@
+#ifndef NIM_NODE_SDK_CLIENT_H
+#define NIM_NODE_SDK_CLIENT_H
+
+#include <node.h>
+#include <node_object_wrap.h>
+#include "nim_cpp_wrapper/helper/nim_client_helper.h"
+#include "nim_node_helper.h"
+
+namespace nim_node {
+class Client : public node::ObjectWrap {
+private:
+    /* data */
+public:
+    static void New(const FunctionCallbackInfo<Value>& args);
+    static void InitModule(Local<Object>& module);
+
+public:
+    NIM_SDK_NODE_API(Init);
+    NIM_SDK_NODE_API(GetSDKConfig);
+    NIM_SDK_NODE_API(CleanUp);
+    NIM_SDK_NODE_API(CleanUp2);
+    NIM_SDK_NODE_API(LoginCustomDataToJson);
+    NIM_SDK_NODE_API(Login);
+    NIM_SDK_NODE_API(GetLoginState);
+    NIM_SDK_NODE_API(Relogin);
+    NIM_SDK_NODE_API(Logout);
+    NIM_SDK_NODE_API(KickOtherClient);
+    NIM_SDK_NODE_API(RegReloginCb);
+    NIM_SDK_NODE_API(RegKickoutCb);
+    NIM_SDK_NODE_API(RegDisconnectCb);
+    NIM_SDK_NODE_API(RegMultispotLoginCb);
+    NIM_SDK_NODE_API(RegKickOtherClientCb);
+    NIM_SDK_NODE_API(RegSyncMultiportPushConfigCb);
+    NIM_SDK_NODE_API(SetMultiportPushConfigAsync);
+    NIM_SDK_NODE_API(GetMultiportPushConfigAsync);
+    NIM_SDK_NODE_API(GetSDKVersion);
+    NIM_SDK_NODE_API(GetServerCurrentTime);
+    NIM_SDK_NODE_API(GetCurrentUserAccount);
+    NIM_SDK_NODE_API(UnregClientCb);
+
+protected:
+    Client(Isolate* isolate);
+    ~Client();
+
+private:
+    DECLARE_CLASS;
+
+    Isolate* isolate_;
+};
+}  // namespace nim_node
+
+#endif  // NIM_NODE_SDK_CLIENT_H

package/src/api/nim_node_client_event_handler.cpp

@@ -0,0 +1,269 @@
+#include "nim_node_client_event_handler.h"
+#include "../helper/nim_node_client_helper.h"
+#include "nim_node_async_queue.h"
+#include "nim_node_helper.h"
+// #include "DbgHelp.h"
+#include <sstream>
+
+namespace nim_node {
+// string TraceStack()
+// {
+// 	static const int MAX_STACK_FRAMES = 5;
+
+// 	void *pStack[MAX_STACK_FRAMES];
+
+// 	HANDLE process = GetCurrentProcess();
+// 	SymInitialize(process, NULL, TRUE);
+// 	WORD frames = CaptureStackBackTrace(0, MAX_STACK_FRAMES, pStack, NULL);
+
+// 	std::ostringstream oss;
+// 	oss << "stack traceback: " << std::endl;
+// 	for (WORD i = 0; i < frames; ++i) {
+// 		DWORD64 address = (DWORD64)(pStack[i]);
+
+// 		DWORD64 displacementSym = 0;
+// 		char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
+// 		PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
+// 		pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+// 		pSymbol->MaxNameLen = MAX_SYM_NAME;
+
+// 		DWORD displacementLine = 0;
+// 		IMAGEHLP_LINE64 line;
+// 		//SymSetOptions(SYMOPT_LOAD_LINES);
+// 		line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+
+// 		if (SymFromAddr(process, address, &displacementSym, pSymbol)
+// 		 && SymGetLineFromAddr64(process, address, &displacementLine,
+// &line)) { 			oss << "\t" << pSymbol->Name << " at " <<
+// line.FileName << ":" << line.LineNumber << "(0x" << std::hex <<
+// pSymbol->Address << std::dec << ")"
+// << std::endl;
+// 		}
+// 		else {
+// 			oss << "\terror: " << GetLastError() << std::endl;
+// 		}
+// 	}
+// 	return oss.str();
+// }
+
+void ClientEventHandler::OnLoginCallback(const BaseCallbackPtr& bcb,
+                                         bool relogin_cb,
+                                         const nim::LoginRes& login_res) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnLoginCallback(bcb, relogin_cb,
+                                                                login_res);
+    });
+}
+
+void ClientEventHandler::Node_OnLoginCallback(const BaseCallbackPtr& bcb,
+                                              bool relogin_cb,
+                                              const nim::LoginRes& login_res) {
+    // printf("###################%s\r", TraceStack().c_str());
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 1;
+    Local<Object> res = Object::New(isolate);
+    nim_client_login_res_to_obj(isolate, login_res, res);
+    Local<Value> argv[argc] = {res};
+    if (bcb != nullptr) {
+        bcb->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                          bcb->data_.Get(isolate), argc, argv);
+    } else {
+        std::string fun_name =
+            relogin_cb ? "OnReloginCallback" : "OnLoginCallback";
+        auto it = callbacks_.find(fun_name);
+        if (it != callbacks_.end()) {
+            it->second->callback_.Get(isolate)->Call(
+                isolate->GetCurrentContext(), it->second->data_.Get(isolate),
+                argc, argv);
+        }
+    }
+}
+
+void ClientEventHandler::OnFunctionCallback() {
+    node_async_call::async_call([]() {
+        ClientEventHandler::GetInstance()->Node_OnFunctionCallback();
+    });
+}
+
+void ClientEventHandler::Node_OnFunctionCallback() {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    auto it = callbacks_.find("OnFunctionCallback");
+    if (it != callbacks_.end()) {
+        it->second->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                                 it->second->data_.Get(isolate),
+                                                 0, nullptr);
+    }
+}
+
+void ClientEventHandler::OnLogoutCallback(const BaseCallbackPtr& bcb,
+                                          nim::NIMResCode rescode) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnLogoutCallback(bcb, rescode);
+    });
+}
+
+void ClientEventHandler::Node_OnLogoutCallback(const BaseCallbackPtr& bcb,
+                                               nim::NIMResCode rescode) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 1;
+    Local<Value> argv[argc] = {Integer::New(isolate, rescode)};
+    bcb->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                      bcb->data_.Get(isolate), argc, argv);
+}
+
+void ClientEventHandler::OnKickoutCallback(const nim::KickoutRes& res) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnKickoutCallback(res);
+    });
+}
+void ClientEventHandler::OnDisconnectCallback() {
+    node_async_call::async_call([]() {
+        ClientEventHandler::GetInstance()->Node_OnDisconnectCallback();
+    });
+}
+void ClientEventHandler::OnMultispotLoginCallback(
+    const nim::MultiSpotLoginRes& res) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnMultispotLoginCallback(res);
+    });
+}
+void ClientEventHandler::OnKickOtherClientCallback(
+    const nim::KickOtherRes& res) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnKickOtherClientCallback(res);
+    });
+}
+void ClientEventHandler::OnSyncMultiportPushConfigCallback(
+    const BaseCallbackPtr& bcb,
+    int rescode,
+    bool open) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()
+            ->Node_OnSyncMultiportPushConfigCallback(bcb, rescode, open);
+    });
+}
+
+void ClientEventHandler::Node_OnKickoutCallback(const nim::KickoutRes& res) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 1;
+    Local<Object> obj = Object::New(isolate);
+    nim_client_kickout_res_to_obj(isolate, res, obj);
+    Local<Value> argv[argc] = {obj};
+    auto it = callbacks_.find("OnKickoutCallback");
+    if (it != callbacks_.end()) {
+        it->second->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                                 it->second->data_.Get(isolate),
+                                                 argc, argv);
+    }
+}
+void ClientEventHandler::Node_OnDisconnectCallback() {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    auto it = callbacks_.find("OnDisconnectCallback");
+    if (it != callbacks_.end()) {
+        it->second->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                                 it->second->data_.Get(isolate),
+                                                 0, nullptr);
+    }
+}
+void ClientEventHandler::Node_OnMultispotLoginCallback(
+    const nim::MultiSpotLoginRes& res) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 1;
+    Local<Object> obj = Object::New(isolate);
+    nim_client_multispot_res_to_obj(isolate, res, obj);
+    Local<Value> argv[argc] = {obj};
+    auto it = callbacks_.find("OnMultispotLoginCallback");
+    if (it != callbacks_.end()) {
+        it->second->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                                 it->second->data_.Get(isolate),
+                                                 argc, argv);
+    }
+}
+void ClientEventHandler::Node_OnKickOtherClientCallback(
+    const nim::KickOtherRes& res) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 1;
+    Local<Object> obj = Object::New(isolate);
+    nim_client_kickother_res_to_obj(isolate, res, obj);
+    Local<Value> argv[argc] = {obj};
+    auto it = callbacks_.find("OnKickOtherClientCallback");
+    if (it != callbacks_.end()) {
+        it->second->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                                 it->second->data_.Get(isolate),
+                                                 argc, argv);
+    }
+}
+void ClientEventHandler::Node_OnSyncMultiportPushConfigCallback(
+    const BaseCallbackPtr& bcb,
+    int rescode,
+    bool open) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 2;
+    Local<Value> argv[argc] = {nim_napi_new_int32(isolate, rescode),
+                               nim_napi_new_bool(isolate, open)};
+    if (bcb == nullptr) {
+        auto it = callbacks_.find("OnSyncMultiportPushConfigCallback");
+        if (it != callbacks_.end()) {
+            it->second->callback_.Get(isolate)->Call(
+                isolate->GetCurrentContext(), it->second->data_.Get(isolate), 2,
+                argv);
+        }
+    } else {
+        bcb->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                          bcb->data_.Get(isolate), argc, argv);
+    }
+}
+
+void ClientEventHandler::OnGetServerCurrentTimeCallback(
+    const BaseCallbackPtr& bcb,
+    int rescode,
+    bool calc_local,
+    uint64_t time) {
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnGetServerCurrentTimeCallback(
+            bcb, rescode, calc_local, time);
+    });
+}
+
+void ClientEventHandler::Node_OnGetServerCurrentTimeCallback(
+    const BaseCallbackPtr& bcb,
+    int rescode,
+    bool calc_local,
+    uint64_t time) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 3;
+    Local<Value> argv[argc] = {nim_napi_new_int32(isolate, rescode),
+                               nim_napi_new_bool(isolate, calc_local),
+                               nim_napi_new_uint64(isolate, time)};
+    bcb->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                      bcb->data_.Get(isolate), argc, argv);
+}
+void ClientEventHandler::OnReloginRequestTokenCb(const BaseCallbackPtr& bcb,
+                                                 std::string* res) {
+    std::string temp = *res;
+    node_async_call::async_call([=]() {
+        ClientEventHandler::GetInstance()->Node_OnReloginRequestTokenCb(bcb,
+                                                                        temp);
+    });
+}
+
+void ClientEventHandler::Node_OnReloginRequestTokenCb(
+    const BaseCallbackPtr& bcb,
+    std::string res) {
+    Isolate* isolate = Isolate::GetCurrent();
+    HandleScope scope(isolate);
+    const unsigned argc = 1;
+    Local<Value> argv[argc] = {nim_napi_new_utf8string(isolate, res.c_str())};
+    bcb->callback_.Get(isolate)->Call(isolate->GetCurrentContext(),
+                                      bcb->data_.Get(isolate), argc, argv);
+}
+}  // namespace nim_node