Send events from nodejs addon to javascript

You do not need a separate v8::Isolate to call V8 from your code, you'd only want one if you wanted multiple v8 engines to run multiple Javascript interpreters in parallel.

I think the reason for your problem is that you're calling V8 from another thread, which is quite risky. Use an uv_acync_t struct to signal your 'main/V8' thread from your C++ addon thread. See this thread for more details on how to do this.

Besides, MakeCallback is not the proper way to fire off callbacks, see https://github.com/nodejs/nan/issues/284.

The common practice for emitting events from a Node.js C++ addon module is to wrap the C++ component with a javascript component and ship them together as a single module. The javascript component passes a callback into the c++ component. When the C++ component receives an event, it should call the javascript callback, which should in turn, use an EventEmitter to emit the event.

If you'd like to see an example of this in practice, I do this in my node-dvbtee addon module: http://github.com/mkrufky/node-dvbtee

The C++ addon source is built from the src/ directory.

The javascript wrapper can be found in the lib/ directory.

Look inside lib/parser.js to find where the function listenTables is called with a callback function as it's parameter. Depending on the module's configured options, that callback will either call self.push() (for streaming) or self.emit() to emit an event.

To avoid link rot, the javascript sample looks like this:

var _Dvbtee = require('bindings')('dvbtee.node')
var util    = require('util')
var stream  = require('stream')

var Parser = function (options) {

    var self = this

    if (!(this instanceof Parser)) {
      return new Parser(options)
    }

    self.options = {}

    if (typeof options === 'object') {
      self.options.passThru = (options.hasOwnProperty('passThru') && options.passThru)
    } else {
      self.options.passThru = false
    }

    var _parser       = new _Dvbtee.Parser

    var _listenTables = _Dvbtee.Parser.prototype.listenTables
    var listenTables  = _listenTables.bind(_parser)

    stream.Transform.call(this, {
      objectMode: !self.options.passThru
    })

    self._buffer = new Buffer(0)

    listenTables(function(a,b,c) {
          // arguments a & b are ignored
          self.emit('psip', c)
    })
}

util.inherits(Parser, stream.Transform)

Parser.prototype._transform = ...

The c++ addon component would have to store the supplied callback function in a persistent handle. NAN provides a perfect structure for this: Nan::Callback

The c++ addon component code should look something like the following:

void dvbteeParser::listenTables(const Nan::FunctionCallbackInfo<v8::Value>& info) {
  dvbteeParser* obj = ObjectWrap::Unwrap<dvbteeParser>(info.Holder());

  int lastArg = info.Length() - 1;

  if ((lastArg >= 0) && (info[lastArg]->IsFunction())) {
    obj->m_tableReceiver.subscribe(info[lastArg].As<v8::Function>());
  }

  info.GetReturnValue().Set(info.Holder());
}

...

void TableReceiver::subscribe(const v8::Local<v8::Function> &fn) {
  m_cb.SetFunction(fn);
}

... where m_cb is a Nan::Callback inside my TableReceiver class. You can actually call this callback in your native addon's event generating function like so:

v8::Local<v8::Value> argv[] = {
  a,
  b,
  c
};

m_cb.Call(3, argv);

where a, b and c are of type v8::Local<v8::Value>. Of course, the argv array could have any size. Each element corresponds to an argument supplied to the given callback function.