How to get callbacks from native cpp code.

[jay11ca39]

I am new to Native addon concept. I am using NAN to build my native addon.

Following are my layers:

1. C++ shared library
2. Native addon layer [NAN layer]
3. Javascript APIs
4. Javascript Application

I have some query regarding callback mechanism:

How my addon layer will get the callbacks from Native layer [C++ library].
Do i have to use libuv to get callbacks from c++ layer or there are other ways to do so?

Thanks in advance.

[gireeshpunathil]

what is the relation between your NAN layer and the shared library layer? Does the addon consume some services from the library? then there is no libuv support is required, you invoke the library to avail the functions in the normal manner. On the other hand, if the library is a consumer of libuv and receives event callbacks already and if you want to relay those callback into the addon, the shlib should provide interfaces (event registration functions), addon should register with them, and then the callback from the shlib can pipe them through the callback hooks.

If you have further questions, please elaborate with a specific case, probably with sample code to show what you are trying to achieve.

[jay11ca39]

Hi @gireeshpunathil ,

Thanks for your reply.

My CPP library is PUB/SUB library.
For example:

1. One publisher : will push data.
2. One subscriber : will subscribe for data.

So, CPP subscriber side will recieve data asynchronously. [Whenever publisher publish]
Addon Layer will register the callback to native layer to receive data as and when native layer receive data.
Addon layer will send wrapped data that it received in callback to js layer [application]

Please let me know if it makes sense?

[gireeshpunathil]

@jay11ca39 - thanks. So, you need 2 things, if I understand it right:

• ability to get called back from pub/sub lib into the native addon
• ability to call JS code from native addon.

Please confirm if this is what you wanted.

as pub/sub is already capable of asynchronous data handling, libuv is not required. So all what you need is a mechanism for the native addon to register for being called back. Normal C/C++ semantics, no JS / node specific:

1. define a function as native addon (say foo)
2. define a function pointer in the pub/sub library of comparable type with foo
3. define a registration method in pub/sub lib - that takes a function pointer as argument. Additional input can be defined based on predicates and conditions you want to apply.
4. In the registration function, cache the incoming fn. pointer.
5. Upon intercepting async data, and applying the predicates as relevant, invoke the callback through the cached pointer.
6. On the native addon side, invoke the registration function of the library with the addon as the input.

this setup will provide calling back into the addon. Now to go to JS from the addon, use one of the appropriate Call family of methods from nan.

Does this sound reasonable to you?

[jay11ca39]

Hi @gireeshpunathil ,

Yes, I want the same:

• ability to get called back from pub/sub lib into the native addon
• ability to call JS code from native addon.

Following are my layers:

1. C++ shared library
2. Native addon layer
3. Javascript APIs
4. Javascript Application

What i am trying:

Native C++ class

typedef std::function<void(int errorCode)> nativeCallback;
Class NativeClass 
{
  public:
       NativeClass() {}   
       setCallback(nativeCallback cb) //some function of this clas will call this callback later...
       ....................

};

Addon class

Class AddonClass
{
  public:
       AddonClass() {}   
       static addonCallback(AddonClass *pointer) {} 
       ....................

};

I tried the follwing:
Define a static function in addon layer and pass it to the native cpp layer.
Result:
I am getting the native callback in my addon layer. But when i am trying to call it to javascript using :

void AddonClass::addonCallback(AddonClass *pointer) //This object is maintained using std::bind
{

        std::cout <<"[Addon addonCallback] Before getting handle"<<std::endl;
        pointer->handle();   --------------------->   **//This is crashing** 
        std::cout <<"[Addon addonCallback] After getting handle"<<std::endl;
       v8::Local<v8::Value> argv[] = { Nan::New("onEvent").ToLocalChecked() };
       pointer->emit->Call(pointer->handle(), 1, argv);

}

When i added Nan::HandleScope scope before getting the handle it is also crashing.

Note: I am trying to use event emmiter concept for giving the callbacks to javascript layer.

[gireeshpunathil]

@jay11ca39 - there are at least 3 ways to invoke a callback, at high level:

1. If you statically know the target method who is responsible for handling the event, invoke it directly with the argument data.
2. If you don't know the target method, but know the receiver object upon which the event has occurred, invoke it's emit method with the argument data.
3. In both the cases above, if your calling in is synchronous (i.e., the sequence of instructions that lead upto invocation of the original async function and the current callback context is in the same control flow without any other unrelated code ran in between) then you may want to mimic an async behavior through skipping the current execution cycle and call the callback in the next one - this requires libuv support (process.nextTick ...)

Assuming you are interested in (1), here is the sample code. You can extend it to (2) or (3) as you like:

#cat foo.cc

#include <nan.h>

Nan::MaybeLocal<v8::Function> fn;
v8::Local<v8::Value> argv[] {Nan::Null()};
Nan::Callback cb;

NAN_METHOD(Register) {
  const v8::Local<v8::Function> val = Nan::To<v8::Function>(info[0]).ToLocalChecked();
  cb.Reset(val);
}

NAN_METHOD(Invoke) {
  cb.Call(1, argv);
}

NAN_MODULE_INIT(Init) {
Nan::Set(target
    , Nan::New<v8::String>("register").ToLocalChecked()
    , Nan::New<v8::FunctionTemplate>(Register)->GetFunction()
  );
Nan::Set(target
    , Nan::New<v8::String>("invoke").ToLocalChecked()
    , Nan::New<v8::FunctionTemplate>(Invoke)->GetFunction()
  );
}

NODE_MODULE(addon, Init)

#cat binding.gyp

{
  "targets": [
    {
    "xcode_settings": {
     "OTHER_CPLUSPLUSFLAGS": [ "'-I../../../node_modules/nan'"],
    },
      "target_name": "testmodule",
      "sources": [ "foo.cc" ]
    }
  ]
}

#cat foo.js

const tm = require('./testmodule');
function foo() {
  console.log('hey, I am a callback!')
  console.trace();
}
tm.register(foo);
tm.invoke();

#node-gyp configure build V=1

gyp info it worked if it ends with ok
gyp info using node-gyp@3.6.2
gyp info using node@9.8.0 | darwin | x64
gyp info spawn /usr/local/bin/python2
...
gyp info ok 

#cp build/Release/testmodule.node ./testmodule.node
#node foo.js

hey, I am a callback!
Trace
    at foo (/home/gireesh/support/1171/foo.js:4:11)
    at Object.<anonymous> (/home/gireesh/support/1171/foo.js:7:4)
    at Module._compile (module.js:649:30)
    at Object.Module._extensions..js (module.js:660:10)
    at Module.load (module.js:561:32)
    at tryModuleLoad (module.js:501:12)
    at Function.Module._load (module.js:493:3)
    at Function.Module.runMain (module.js:690:10)
    at startup (bootstrap_node.js:194:16)
    at bootstrap_node.js:666:3
#

Hope this helps!

[jay11ca39]

@gireeshpunathil ,
Thank you very much for your detailed explaination.
I understood and run your sample it worked well.

But when i modified your approch to achieve my scenario it crashed while calling the javascript callback.
Following is the code I tried:

You are calling javascript callback from here:

NAN_METHOD(Invoke) {
  cb.Call(1, argv);
}

I have to call this callback from addon callback which i will register to cpp library :

Class AddonClass
{
  public:
       AddonClass() {}   
       static addonCallback() //This will be called from C++ library
      {   
          cb.Call(1, argv);   //This result in crash
      } 
};

So, does it mean i can call javascript callback only from NAN_METHOD and not from my addon class other methods?

Is there is anything I missed or there is some other mechanism I have to use...

[jay11ca39]

Sorry for asking many things.
I want to send other addon class object rather than primitive types in NAN::Callback . Is it possible?
I went through the documentation of NAN for this but could not get much on this.
NAN::Callback

As per documentation:

  v8::Local<v8::Value> Call(v8::Local<v8::Object> target,
                            int argc,
                            v8::Local<v8::Value> argv[]) const;

  v8::Local<v8::Value> Call(int argc, v8::Local<v8::Value> argv[]) const;

I am trying to achieve this:

Class AddonA
{
     // here in the callback of class A I want to send object of Class B with value member = 100 to js layer
};

Class B
{
  public: 
    int value;
};

[gireeshpunathil]

no, there exist no such restrictions. The crash reason probably is your cb is not properly registered or initialized within your AddonClass. Mind sharing the whole AddonClass code?

[gireeshpunathil]

you can send user defined objects through NAN:Callback, but not C++ objects! As the NAN::Callback is destined to JS land, your objects have to be JS objects! sounds reasonable?

[jay11ca39]

Hello @gireeshpunathil ,
Thanks for your reply.

Following is my addon class:

NSubscriber.h

#ifndef N_SUBSCRIBER_H
#define N_SUBSCRIBER_H

#include <nan.h>

#include "NSubscriber.h"

using namespace Nan;
using namespace v8;

namespace npubsub
{
    class NSubscriber : public Nan::ObjectWrap
    {
        public:
            static NAN_MODULE_INIT(Init);
            static v8::Local<v8::Object> NewInstance();

            //callback functions
            static void subCallback(const Message &event, NSubscriber *obj);

        private:
            explicit NSubscriber();
            void NMakeNative(std::string address);

            static NAN_METHOD(New);
            static NAN_METHOD(Subscribe);

            static inline Nan::Persistent<v8::Function> & constructor()
            {
                static Nan::Persistent<v8::Function> constructor;
                return constructor;
            }

            pubsub::Subscriber *nativeHandle;
    };
}
#endif //N_SUBSCRIBER_H

NSubscriber.cpp

#include "NSubscriber.h"

using namespace v8;

namespace npubsub
{
    Nan::MaybeLocal<v8::Function> fn;
    v8::Local<v8::Value> argv[] {Nan::Null()};
    Nan::Callback gcb;

    NAN_MODULE_INIT(NSubscriber::Init)
    {
        // Prepare constructor template
        v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
        tpl->SetClassName(Nan::New("NSubscriber").ToLocalChecked());
        tpl->InstanceTemplate()->SetInternalFieldCount(1);

        // Function Prototypes
        Nan::SetPrototypeMethod(tpl, "subscribe", Subscribe);

        constructor().Reset(GetFunction(tpl).ToLocalChecked());
        Nan::Set(target, Nan::New("NSubscriber").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
    }

    v8::Local<v8::Object> NSubscriber::NewInstance()
    {
        v8::Local<v8::Function> cons = Nan::New(constructor());
        return Nan::NewInstance(cons).ToLocalChecked();
    }

    NSubscriber::NSubscriber() : Nan::ObjectWrap()
    {	

    }
	
    void NSubscriber::NMakeNative(std::string address)
    {
       //make a cpp object and store it in nativeHandle
	nativeHandle =  new pubsub::Subscriber(address, std::bind(NSubscriber::subCallback, std::placeholders::_1, this));	
     }
	
    //The below method is being called from native layer properly....
    void NSubscriber::subCallback(const EZMQMessage &message,  NSubscriber *obj)
    {
       std::cout <<"[Addon subCallback] Received data from CPP layer"<<std::endl;
       nezmq::gcb.Call(1, nezmq::argv);  // ***************** Here it is crashing 
	  
	// one more question here:
	// 1. Suppose I have one more class in addon layer that is NMessage and I want to send object
	// of that class in above callback, how can I do that?  
    }

    NAN_METHOD(NSubscriber::New)
    {
        Isolate* isolate = info.GetIsolate();
        if (info.IsConstructCall())
        {
            //Get address
            Local<String> str = Local<String>::Cast(info[0]);
            String::Utf8Value utfValue(str);

            NSubscriber* obj = new NSubscriber();
            obj->NEZMQMakeNative(*utfValue);

            //Get Callback
            const v8::Local<v8::Function> val = Nan::To<v8::Function>(info[2]).ToLocalChecked();
            gcb.Reset(val);

            obj->Wrap(info.This());
            info.GetReturnValue().Set(info.This());
        }
        else
        {
        }
    }
	
    NAN_METHOD(NSubscriber::Subscribe)
    {
       NSubscriber* obj = ObjectWrap::Unwrap<NSubscriber>(info.Holder());
       info.GetReturnValue().Set(Nan::New<Integer>((obj->nativeHandle)->subscribe()));
    }
}

[jay11ca39]

When I just tried to call the js callback from subscribe method itself it is working well..

like this:

 NAN_METHOD(NSubscriber::Subscribe)
    {
       NSubscriber* obj = ObjectWrap::Unwrap<NSubscriber>(info.Holder());
       info.GetReturnValue().Set(Nan::New<Integer>((obj->nativeHandle)->subscribe()));

         npubsub::gcb.Call(1, npubsub::argv);   //It is working fine .. I am able to get callback to js application.
    }

The same thing is crashing when i called from my addon callback [subCallback] which will be called from c++ layer..

[gireeshpunathil]

can you paste here the call stack from the crash?

[jay11ca39]

Hello @gireeshpunathil

Following is the stack trace:

(gdb) bt
#0  0x0000000000aeb4a3 in v8::EscapableHandleScope::EscapableHandleScope(v8::Isolate*) ()
#1  0x00007ffff49ab185 in npubsub::NSubscriber::subCallback(pubsub::pubsubMessage const&, npubsub::NSubscriber*) ()
   from /home/jay/nodesdk/pubsub-node/build/Release/pubsub.node
#2  0x00007ffff4757a5d in std::function<void (pubsub::pubsubMessage const&)>::operator()(pubsub::pubsubMessage const&) const (this=0x2257e28,
    __args#0=...) at /usr/include/c++/4.8/functional:2471
#3  0x00007ffff4752549 in pubsub::Subscriber::parseSocketData (this=0x2257e00) at src/Subscriber.cpp:138
#4  0x00007ffff4752fe7 in pubsub::Subscriber::receive (this=0x2257e00) at src/Subscriber.cpp:180
#5  0x00007ffff475bbb5 in std::_Mem_fn<void (pubsub::Subscriber::*)()>::operator()<, void>(pubsub::Subscriber*) const (this=0x2282598,
    __object=0x2257e00) at /usr/include/c++/4.8/functional:601
#6  0x00007ffff475ba87 in std::_Bind_simple<std::_Mem_fn<void (pubsub::Subscriber::*)()> (pubsub::Subscriber*)>::_M_invoke<0ul>(std::_Index_tuple<0ul>) (this=0x2282590) at /usr/include/c++/4.8/functional:1732
#7  0x00007ffff475b82f in std::_Bind_simple<std::_Mem_fn<void (pubsub::Subscriber::*)()> (pubsub::Subscriber*)>::operator()() (
    this=0x2282590) at /usr/include/c++/4.8/functional:1720
#8  0x00007ffff475b75c in std::thread::_Impl<std::_Bind_simple<std::_Mem_fn<void (pubsub::Subscriber::*)()> (pubsub::Subscriber*)> >::_M_run() (this=0x2282578) at /usr/include/c++/4.8/thread:115
#9  0x00007ffff774c5b0 in ?? () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#10 0x00007ffff6f88184 in start_thread (arg=0x7fffe6de4700) at pthread_create.c:312
#11 0x00007ffff6cb503d in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111

[gireeshpunathil]

• is gcb part of NSubscriber class? what is nezmq in nezmq::gcb?
• the crash reason is due to lack of scoping . Can you please review and apply this nan doc - specifically:
  • Allocate a new Nan::HandleScope whenever you are creating new V8 JavaScript objects.
  • Nan::EscapableHandleScope: Similar to Nan::HandleScope but should be used in cases where a function needs to return a V8 JavaScript type that has been created within it.

[jay11ca39]

Hello @gireeshpunathil

is gcb part of NSubscriber class? what is nezmq in nezmq::gcb?

• I was testing some other thing and pasted wrongly in above comment:
  Below is the code that i meant:

 NAN_METHOD(NSubscriber::Subscribe)
    {
       NSubscriber* obj = ObjectWrap::Unwrap<NSubscriber>(info.Holder());
       info.GetReturnValue().Set(Nan::New<Integer>((obj->nativeHandle)->subscribe()));

         npubsub::gcb.Call(1, npubsub::argv);   //It is working fine .. I am able to get callback to js application.
    }

I will try to apply.. so as per you if i can make use of scoping in my addon callback to call js callback right?