@4players/odin-nodejs 0.7.0

package/cppsrc/odinroom.cpp

@@ -0,0 +1,738 @@
+//
+// Created by Phillip Schuster on 11.02.23.
+//
+
+#include "odinroom.h"
+#include <string>
+#include <iostream>
+#include <codecvt>
+#include <locale>
+#include "odinmedia.h"
+
+using namespace std;
+
+// Required, otherwise an unknown symbol error comes up
+Napi::FunctionReference* OdinRoom::constructor;
+
+/**
+ * Prepares a NAPI value object for the event
+ * @param env
+ * @param event The event data
+ * @return
+ */
+Napi::Object OdinRoom::PrepareEventObject(Napi::Env env, const EventData *event) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("event", event->Event);
+    obj.Set("tag", (int)event->Tag);
+    switch(event->Tag) {
+        case OdinEvent_Joined: {
+            const JoinedEventData *joined = static_cast<const JoinedEventData*>(event);
+            obj.Set("roomId", joined->RoomId);
+            obj.Set("ownPeerId", joined->PeerId);
+            obj.Set("ownUserId", joined->UserId);
+            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)joined->Data, joined->DataLen);
+            Napi::Uint8Array array = Napi::Uint8Array::New(env, joined->DataLen, buffer, 0, napi_uint8_array);
+            obj.Set("roomUserData", array);
+            break;
+        }
+        case OdinEvent_PeerJoined: {
+            const PeerJoinedEventData *joined = static_cast<const PeerJoinedEventData*>(event);
+            obj.Set("peerId", joined->PeerId);
+            obj.Set("userId", joined->UserId);
+            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)joined->Data, joined->DataLen);
+            Napi::Uint8Array array = Napi::Uint8Array::New(env, joined->DataLen, buffer, 0, napi_uint8_array);
+            obj.Set("userData", array);
+            break;
+        }
+        case OdinEvent_PeerLeft: {
+            const PeerLeftEventData *left = static_cast<const PeerLeftEventData*>(event);
+            obj.Set("peerId", left->PeerId);
+            break;
+        }
+        case OdinEvent_PeerUserDataChanged: {
+            const PeerUserDataChangedEventData *changed = static_cast<const PeerUserDataChangedEventData*>(event);
+            obj.Set("peerId", changed->PeerId);
+            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)changed->Data, changed->DataLen);
+            Napi::Uint8Array array = Napi::Uint8Array::New(env, changed->DataLen, buffer, 0, napi_uint8_array);
+            obj.Set("userData", array);
+            break;
+        }
+        case OdinEvent_RoomUserDataChanged: {
+            const RoomUserDataChangedEventData *changed = static_cast<const RoomUserDataChangedEventData*>(event);
+            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)changed->Data, changed->DataLen);
+            Napi::Uint8Array array = Napi::Uint8Array::New(env, changed->DataLen, buffer, 0, napi_uint8_array);
+            obj.Set("userData", array);
+            break;
+        }
+        case OdinEvent_MessageReceived: {
+            const MessageReceivedEventData *message = static_cast<const MessageReceivedEventData*>(event);
+            obj.Set("peerId", message->PeerId);
+            Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, (void*)message->Data, message->DataLen);
+            Napi::Uint8Array array = Napi::Uint8Array::New(env, message->DataLen, buffer, 0, napi_uint8_array);
+            obj.Set("messageData", array);
+            break;
+        }
+        case OdinEvent_RoomConnectionStateChanged: {
+            const RoomConnectionStateChangedEventData *state = static_cast<const RoomConnectionStateChangedEventData*>(event);
+            obj.Set("state", state->StateName);
+            obj.Set("reason", state->ReasonName);
+            break;
+        }
+        case OdinEvent_MediaAdded: {
+            const MediaAddedEventData *added = static_cast<const MediaAddedEventData*>(event);
+            obj.Set("peerId", added->PeerId);
+            obj.Set("mediaId", added->MediaId);
+            break;
+        }
+        case OdinEvent_MediaRemoved: {
+            const MediaRemovedEventData *removed = static_cast<const MediaRemovedEventData*>(event);
+            obj.Set("peerId", removed->PeerId);
+            obj.Set("mediaId", removed->MediaId);
+            break;
+        }
+        case OdinEvent_MediaActiveStateChanged: {
+            const MediaActiveStateChangedEventData *activity = static_cast<const MediaActiveStateChangedEventData*>(event);
+            obj.Set("peerId", activity->PeerId);
+            obj.Set("mediaId", activity->MediaId);
+            obj.Set("state", activity->Active);
+            break;
+        }
+    }
+
+    return obj;
+}
+
+/**
+ * Returns the room id as string of this room instance
+ * @param info
+ */
+Napi::Value OdinRoom::RoomId(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    char out_id[512];
+    OdinReturnCode error = odin_room_id(_roomHandle, out_id, sizeof(out_id));
+    if (odin_is_error(error))
+    {
+        Napi::TypeError::New(env, "Failed to get room id").ThrowAsJavaScriptException();
+    }
+
+    return Napi::String::New(env, out_id);
+}
+
+/**
+ * Returns the room handle of this room instance
+ */
+OdinRoomHandle OdinRoom::GetRoomHandle() const {
+    return _roomHandle;
+}
+
+/**
+ * Returns the media id of a media stream handle, used internally to map media stream handles to media ids in event callbacks
+ */
+uint16_t OdinRoom::GetMediaIdFromHandle(OdinMediaStreamHandle handle)
+{
+    uint16_t media_id;
+    int error = odin_media_stream_media_id(handle, &media_id);
+    return odin_is_error(error) ? 0 : media_id;
+}
+
+/**
+ * Creates an EventData object instance from an OdinEvent. As OdinEvents are allocated on the Odin SDK side, we need to
+ * copy the data as the callbacks to the JS side are asynchronous.
+ * @param event
+ * @return EventData
+ */
+EventData* OdinRoom::PrepareEventData(OdinEvent* event)
+{
+    switch(event->tag) {
+        case OdinEvent_Joined: {
+            JoinedEventData* data = new JoinedEventData();
+            data->Tag = event->tag;
+            data->Event = "Joined";
+            data->RoomId = event->joined.room_id;
+            data->UserId = event->joined.own_user_id;
+            data->PeerId = event->joined.own_peer_id;
+            data->SetData(event->joined.room_user_data, event->joined.room_user_data_len);
+            return data;
+        }
+        case OdinEvent_PeerJoined: {
+            PeerJoinedEventData* data = new PeerJoinedEventData();
+            data->Tag = event->tag;
+            data->Event = "PeerJoined";
+            data->PeerId = event->peer_joined.peer_id;
+            data->UserId = event->peer_joined.user_id;
+            data->SetData(event->peer_joined.peer_user_data, event->peer_joined.peer_user_data_len);
+            return data;
+        }
+        case OdinEvent_PeerLeft: {
+            PeerLeftEventData* data = new PeerLeftEventData();
+            data->Tag = event->tag;
+            data->Event = "PeerLeft";
+            data->PeerId = event->peer_left.peer_id;
+            return data;
+        }
+        case OdinEvent_PeerUserDataChanged: {
+            PeerUserDataChangedEventData* data = new PeerUserDataChangedEventData();
+            data->Tag = event->tag;
+            data->Event = "PeerUserDataChanged";
+            data->PeerId = event->peer_user_data_changed.peer_id;
+            data->SetData(event->peer_user_data_changed.peer_user_data, event->peer_user_data_changed.peer_user_data_len);
+            return data;
+        }
+        case OdinEvent_RoomUserDataChanged: {
+            RoomUserDataChangedEventData* data = new RoomUserDataChangedEventData();
+            data->Tag = event->tag;
+            data->Event = "RoomUserDataChanged";
+            data->SetData(event->room_user_data_changed.room_user_data, event->room_user_data_changed.room_user_data_len);
+            return data;
+        }
+        case OdinEvent_MessageReceived: {
+            MessageReceivedEventData* data = new MessageReceivedEventData();
+            data->Tag = event->tag;
+            data->Event = "MessageReceived";
+            data->PeerId = event->message_received.peer_id;
+            data->SetData(event->message_received.data, event->message_received.data_len);
+            return data;
+        }
+        case OdinEvent_RoomConnectionStateChanged: {
+            RoomConnectionStateChangedEventData* data = new RoomConnectionStateChangedEventData();
+            data->Tag = event->tag;
+            data->Event = "ConnectionStateChanged";
+            data->State = (int)event->room_connection_state_changed.state;
+            data->Reason = (int)event->room_connection_state_changed.reason;
+            data->StateName = OdinUtilities::GetNameFromConnectionState(event->room_connection_state_changed.state);
+            data->ReasonName = OdinUtilities::GetNameFromConnectionStateChangeReason(event->room_connection_state_changed.reason);
+            return data;
+        }
+        case OdinEvent_MediaAdded: {
+            MediaAddedEventData* data = new MediaAddedEventData();
+            data->Tag = event->tag;
+            data->Event = "MediaAdded";
+            data->PeerId = event->media_added.peer_id;
+            data->MediaId = GetMediaIdFromHandle(event->media_added.media_handle);
+            data->MediaStreamHandle = event->media_added.media_handle;
+            return data;
+        }
+        case OdinEvent_MediaRemoved: {
+            MediaRemovedEventData* data = new MediaRemovedEventData();
+            data->Tag = event->tag;
+            data->Event = "MediaRemoved";
+            data->PeerId = event->media_removed.peer_id;
+            data->MediaId = GetMediaIdFromHandle(event->media_removed.media_handle);
+            return data;
+        }
+        case OdinEvent_MediaActiveStateChanged: {
+            MediaActiveStateChangedEventData *data = new MediaActiveStateChangedEventData();
+            data->Tag = event->tag;
+            data->Event = "MediaActivity";
+            data->PeerId = event->media_active_state_changed.peer_id;
+            data->MediaId = GetMediaIdFromHandle(event->media_active_state_changed.media_handle);
+            data->Active = event->media_active_state_changed.active;
+            return data;
+        }
+        default:
+            return NULL;
+    }
+
+    return NULL;
+}
+
+/**
+ * Callback function for Odin events. This function is called by the Odin SDK when an event occurs. It creates an EventData
+ * object instance from the OdinEvent and calls the JavaScript callback function with the event data.
+ * @param room OdinRoomHandle
+ * @param event OdinEvent
+ * @param data void* Pointer to the OdinRoom instance
+ */
+void OdinRoom::HandleOdinEvent(OdinRoomHandle room, const OdinEvent *event, void *data)
+{
+    OdinRoom* odinRoom = (OdinRoom*)data;
+    if (odinRoom != NULL) {
+
+        ::uint16_t mediaId = OdinRoom::GetMediaIdFromHandle(event->media_added.media_handle);
+        if (event->tag == OdinEvent_MediaAdded) {
+            Media media;
+            media.PeerId = event->media_added.peer_id;
+            media.Id = mediaId;
+            media.Handle = event->media_added.media_handle;
+            odinRoom->_mediaStreams[media.Id] = media;
+        } else if (event->tag == OdinEvent_MediaRemoved) {
+            if (odinRoom->_mediaStreams.find(mediaId) != odinRoom->_mediaStreams.end()) {
+                odinRoom->_mediaStreams.erase(mediaId);
+            }
+        }
+
+        auto callback = []( Napi::Env env, Napi::Function jsCallback, void* value ) {
+            EventData* eventData = (EventData*)value;
+            if (eventData == NULL) {
+                // I have no idea how to call a function without a parameter ;-)
+                // This should never happen anyway
+                jsCallback.Call({Napi::Number::New( env, 42 )});
+            } else {
+                Napi::Object obj = PrepareEventObject(env, eventData);
+                jsCallback.Call( {obj} );
+                delete eventData;
+            }
+        };
+        if (odinRoom->_eventListener != NULL)
+        {
+            EventData* data = odinRoom->PrepareEventData((OdinEvent*)event);
+#ifdef DEBUG
+            printf("Odin NodeJS Addon: Sending event to JS: %s\n", data->Event.c_str());
+#endif
+            odinRoom->_eventListener.BlockingCall( (void*)data, callback );
+        }
+
+        EventData* data = odinRoom->PrepareEventData((OdinEvent*)event);
+        Napi::ThreadSafeFunction function = odinRoom->_eventListeners[data->Event];
+        if (function != NULL) {
+            function.BlockingCall( (void*)data, callback );
+        }
+
+    } else {
+        printf("Odin NodeJS Addon: No room available when handling events - this should NEVER HAPPEN.\n");
+    }
+}
+
+/**
+ * Creates a new OdinRoom instance. Requires an Odin token as a parameter.
+ * @param info Napi::CallbackInfo
+ */
+OdinRoom::OdinRoom(const Napi::CallbackInfo& info) :Napi::ObjectWrap<OdinRoom>(info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() != 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Provide a token to create a room").ThrowAsJavaScriptException();
+    }
+
+    _token = info[0].ToString().Utf8Value();
+    _roomHandle = odin_room_create();
+    _started = false;
+    _joined = false;
+
+    odin_room_set_event_callback(_roomHandle, OdinRoom::HandleOdinEvent, this);
+}
+
+/**
+ * Destructor. Closes and destroys the OdinRoom and resets the event callback for this room handle.
+ */
+void OdinRoom::Finalize(Napi::Env env) {
+    odin_room_set_event_callback(_roomHandle, NULL, NULL);
+    odin_room_close(_roomHandle);
+    odin_room_destroy(_roomHandle);
+}
+
+/**
+ * Exposes this class to JavaScript
+ * @param info Napi::CallbackInfo
+ */
+Napi::Object OdinRoom::Init(Napi::Env env, Napi::Object exports) {
+    // This method is used to hook the accessor and method callbacks
+    Napi::Function func = DefineClass(env, "OdinRoom", {
+        InstanceMethod<&OdinRoom::Join>("join", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::UpdatePeerUserData>("updateOwnUserData", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::UpdateRoomUserData>("updateRoomUserData", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::SendMessage>("sendMessage", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::SetEventListener>("setEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::AddEventListener>("addEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::RemoveEventListener>("removeEventListener", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::Close>("close", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceMethod<&OdinRoom::CreateAudioStream>("createAudioStream", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceAccessor("ownPeerId", &OdinRoom::GetOwnPeerId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        InstanceAccessor("id", &OdinRoom::RoomId, nullptr, static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+        StaticMethod<&OdinRoom::CreateNewItem>("CreateNewItem", static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+    });
+
+    // We use a static variable to store the constructor. This is because we need to create instances within C++ and
+    // expose to JavaScript. We can't use the constructor directly because it's not exposed to JavaScript.
+    constructor = new Napi::FunctionReference();
+
+    // Create a persistent reference to the class constructor. This will allow
+    // a function called on a class prototype and a function
+    // called on instance of a class to be distinguished from each other.
+    *constructor = Napi::Persistent(func);
+    exports.Set("OdinRoom", func);
+
+    // Store the constructor as the add-on instance data. This will allow this
+    // add-on to support multiple instances of itself running on multiple worker
+    // threads, as well as multiple instances of itself running in different
+    // contexts on the same thread.
+    //
+    // By default, the value set on the environment here will be destroyed when
+    // the add-on is unloaded using the `delete` operator, but it is also
+    // possible to supply a custom deleter.
+    env.SetInstanceData<Napi::FunctionReference>(constructor);
+
+    return exports;
+}
+
+/**
+ * Joins the Odin room. Requires a gateway URL as a parameter and optionally initial peer data.
+ * @param info Napi::CallbackInfo
+ */
+void OdinRoom::Join(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Gateway required as first parameter").ThrowAsJavaScriptException();
+    }
+
+    std::string url = info[0].ToString().Utf8Value();
+
+    if (info.Length() > 1) {
+        Napi::Uint8Array data = info[1].As<Napi::Uint8Array>();
+        OdinReturnCode error = odin_room_update_user_data(_roomHandle, OdinUserDataTarget_Peer, data.Data(), data.ByteLength());
+        if (odin_is_error(error))
+        {
+            Napi::TypeError::New(env, "Setting initial room peer data failed").ThrowAsJavaScriptException();
+        }
+    }
+
+    OdinReturnCode error = odin_room_join(_roomHandle, url.c_str(), _token.c_str());
+    if (odin_is_error(error))
+    {
+        OdinUtilities::ThrowNapiException(env, error, "Failed to join room");
+    }
+
+    _joined = true;
+
+    // Start capturing audio data if event listener has not been started yet
+    if (_audioDataReceivedEventListener) {
+        HandleAudioData();
+    }
+}
+
+/**
+ * Closes the room connection and destroys the room handle.
+ * @param info
+ */
+void OdinRoom::Close(const Napi::CallbackInfo &info) {
+    //Napi::Env env = info.Env();
+
+    if (_roomHandle <= 0) return;
+
+    odin_room_set_event_callback(_roomHandle, NULL, NULL);
+
+    if (this->_eventListener != NULL) {
+        this->_eventListener.Release();
+        this->_eventListener = NULL;
+    }
+
+    for (auto it = _eventListeners.begin(); it != _eventListeners.end(); ++it) {
+        if (it->second != NULL) {
+            it->second.Release();
+            it->second = NULL;
+        }
+    }
+
+    odin_room_close(_roomHandle);
+    odin_room_destroy(_roomHandle);
+    _roomHandle = 0;
+}
+
+/**
+ * Creates a new instance of the OdinRoom class. Requires a token as a parameter.
+ * @param info
+ * @return
+ */
+Napi::Value OdinRoom::CreateNewItem(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Token required as first parameter").ThrowAsJavaScriptException();
+    }
+
+    Napi::String token = info[0].ToString();
+
+    // Retrieve the instance data we stored during `Init()`. We only stored the
+    // constructor there, so we retrieve it here to create a new instance of the
+    // JS class the constructor represents.
+    Napi::FunctionReference* constructor =
+            info.Env().GetInstanceData<Napi::FunctionReference>();
+    return constructor->New({ token });
+}
+
+/**
+ * Creates a new instance of the OdinRoom class. Requires a token as a parameter.
+ * @param info
+ * @return
+ */
+Napi::Object OdinRoom::NewInstance(Napi::Value arg) {
+    return constructor->New({ arg });
+}
+
+/**
+ * Updates the peer user data. Requires an array of bytes as a parameter.
+ * @param info
+ * @return
+ */
+void OdinRoom::UpdatePeerUserData(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() != 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Data as byte array expected").ThrowAsJavaScriptException();
+    }
+
+    Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
+
+    OdinReturnCode error = odin_room_update_user_data(_roomHandle, OdinUserDataTarget_Peer, data.Data(), data.ByteLength());
+
+    if (odin_is_error(error))
+    {
+        OdinUtilities::ThrowNapiException(env, error, "Failed to update peer user data");
+    }
+}
+
+/**
+ * Updates the room user data. Requires an array of bytes as a parameter.
+ * @param info
+ * @return
+ */
+void OdinRoom::UpdateRoomUserData(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() != 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Data as byte array expected").ThrowAsJavaScriptException();
+    }
+
+    Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
+
+    OdinReturnCode error = odin_room_update_user_data(_roomHandle, OdinUserDataTarget_Room, data.Data(), data.ByteLength());
+
+    if (odin_is_error(error))
+    {
+        OdinUtilities::ThrowNapiException(env, error, "Failed to update room user data");
+    }
+}
+
+/**
+ * Sends a message to the room. Requires an array of bytes as a parameter and optinally a list of peer ids to send to.
+ * Please note: If the list is NULL the message will be sent to all peers in the room. If the list is not NULL the message
+ * will be sent to all peers in the list. If the list is empty the message ODIN will raise an error.
+ * @param info
+ * @return
+ */
+void OdinRoom::SendMessage(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Data as byte array expected").ThrowAsJavaScriptException();
+    }
+
+    Napi::Uint8Array data = info[0].As<Napi::Uint8Array>();
+
+    uint64_t *peer_id_list = NULL;
+    size_t peer_id_list_length = 0;
+    if (info.Length() >= 2 && !info[1].IsNull() && !info[1].IsUndefined()) {
+        if (!info[1].IsArray()) {
+            Napi::TypeError::New(env, "Peer id list as uint32 array expected").ThrowAsJavaScriptException();
+        } else {
+            Napi::Array peerIds = info[1].As<Napi::Array>();
+            peer_id_list_length = peerIds.Length();
+            peer_id_list = new uint64_t[peer_id_list_length];
+            for (int i = 0; i < (int)peer_id_list_length; i++) {
+                peer_id_list[i] = peerIds.Get(i).As<Napi::Number>().Uint32Value();
+            }
+        }
+    }
+
+    OdinReturnCode error = odin_room_send_message(_roomHandle, peer_id_list, peer_id_list_length, data.Data(), data.ByteLength());
+
+    if (peer_id_list != NULL) {
+        delete[] peer_id_list;
+    }
+
+    if (odin_is_error(error))
+    {
+        OdinUtilities::ThrowNapiException(env, error, "Failed to update room user data");
+    }
+}
+
+/**
+ * Sets a global event listener for this room. Requires a callback function as a parameter and will receive all events
+ * @param info
+ * @return
+ */
+void OdinRoom::SetEventListener(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() != 1 || !info[0].IsFunction()) {
+        Napi::TypeError::New(env, "Callback function expected").ThrowAsJavaScriptException();
+    }
+
+    Napi::Function napiFunction = info[0].As<Napi::Function>();
+
+    _eventListener = Napi::ThreadSafeFunction::New(env, napiFunction, "Callback", 0, 1);
+}
+
+/**
+ * Adds an event listener for this room. Requires the event type to listen to and a callback function as a second parameter
+ * @param info
+ * @return
+ */
+void OdinRoom::AddEventListener(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() != 2 || !info[0].IsString() || !info[1].IsFunction()) {
+        Napi::TypeError::New(env, "Event Name and Callback function expected").ThrowAsJavaScriptException();
+    }
+
+    std::string eventName = info[0].As<Napi::String>().Utf8Value();
+    Napi::Function napiFunction = info[1].As<Napi::Function>();
+
+    if (eventName != "AudioDataReceived") {
+        _eventListeners[eventName] = Napi::ThreadSafeFunction::New(env, napiFunction, eventName + "Callback", 0, 1);
+    } else {
+        _audioDataReceivedEventListener = Napi::ThreadSafeFunction::New(
+                env,
+                napiFunction,
+                "AudioDataReceivedCallback",
+                0,
+                1,
+                [this](Napi::Env) {
+                    // This is the finalizer thread
+                    this->_nativeThread.join();
+                }
+        );
+
+        HandleAudioData();
+    }
+}
+
+/**
+ * Removes an event listener for this room. Requires the event type to remove the listener for.
+ * @param info
+ * @return
+ */
+void OdinRoom::RemoveEventListener(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() != 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Event Name expected").ThrowAsJavaScriptException();
+    }
+
+    std::string eventName = info[0].As<Napi::String>().Utf8Value();
+
+    if (eventName != "AudioDataReceived") {
+        _eventListeners[eventName].Release();
+        _eventListeners.erase(eventName);
+    } else {
+        _audioDataReceivedEventListener.Release();
+    }
+}
+
+/**
+ * Internal function to receive audio data every 20ms and send it to the JS side. This function will start once the client
+ * has registered AudioDataReceived as an event listener.
+ */
+void OdinRoom::HandleAudioData()
+{
+    if (!_joined) {
+#ifdef DEBUG
+        printf("Odin NodeJS Addon: Skipping audio until joined\n");
+#endif
+        return;
+    }
+
+    if (_started) {
+#ifdef DEBUG
+        printf("Odin NodeJS Addon: Handle Audio Data thread already started\n");
+#endif
+        return;
+    }
+
+    _started = true;
+
+    // Create a native thread
+    _nativeThread = std::thread( [this] {
+        auto callback = []( Napi::Env env, Napi::Function jsCallback, void* value ) {
+            AudioSamples* samples = static_cast<AudioSamples*>( value );
+            // Transform native data into JS data, passing it to the provided
+            // `jsCallback` -- the TSFN's JavaScript function.
+            //Napi::Buffer<float> buffer = Napi::Buffer<float>::New(env, samples->OriginalData, samples->Len);
+            //Napi::ArrayBuffer buffer32 = Napi::ArrayBuffer::New(env, samples->OriginalData, samples->Len*sizeof(float));
+            //Napi::ArrayBuffer buffer16 = Napi::ArrayBuffer::New(env, samples->Data, samples->Len*sizeof(short));
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set("peerId", samples->PeerId);
+            obj.Set("mediaId", samples->MediaId);
+            obj.Set("samples16", Napi::Buffer<short>::New(env, samples->Data, samples->Len));
+            obj.Set("samples32", Napi::Buffer<float>::New(env, samples->OriginalData, samples->Len));
+
+            jsCallback.Call( {obj} );
+
+            // We're finished with the data.
+            delete samples;
+        };
+
+        while (this->_started)
+        {
+            for (auto it = _mediaStreams.begin(); it != _mediaStreams.end(); it++)
+            {
+                OdinReturnCode rc = odin_audio_read_data((OdinMediaStreamHandle)it->second.Handle, this->_audioSamplesBuffer, 960);
+
+                if (odin_is_error(rc)) {
+                    printf("Odin NodeJS Addon: Failed to read audio data\n");
+                    break;
+                }
+
+                AudioSamples* samples = new AudioSamples();
+                samples->SetSamples(this->_audioSamplesBuffer, 960);
+                samples->PeerId = it->second.PeerId;
+                samples->MediaId = it->second.Id;
+
+                // Perform a blocking call
+                napi_status status = _audioDataReceivedEventListener.BlockingCall( samples, callback );
+                if ( status != napi_ok )
+                {
+                    // Handle error
+                    printf("Odin NodeJS Addon: Failed to call audio data received callback\n");
+                    break;
+                }
+            }
+
+            std::this_thread::sleep_for( std::chrono::milliseconds ( 20 ) );
+        }
+
+#ifdef DEBUG
+        printf("Odin NodeJS Addon: Handle Audio Thread finished.");
+#endif
+
+        // Release the thread-safe function
+        _audioDataReceivedEventListener.Release();
+    } );
+}
+
+Napi::Value OdinRoom::CreateAudioStream(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    // Checking for input of sample rate (int) and number of channels (int)
+    if (info.Length() != 2 || !info[0].IsNumber() || !info[1].IsNumber()) {
+        Napi::TypeError::New(env, "Sample rate and number of channels expected").ThrowAsJavaScriptException();
+    }
+
+    if (info.Length() == 3 && !info[2].IsObject()) {
+        Napi::TypeError::New(env, "Options need to be an object").ThrowAsJavaScriptException();
+    }
+
+    if (info.Length() == 2) {
+        return OdinMedia::NewInstance({this->Value(), info[0], info[1]});
+    } else {
+        return OdinMedia::NewInstance({this->Value(), info[0], info[1], info[2]});
+    }
+}
+
+
+/**
+ * Removes an event listener for this room. Requires the event type to remove the listener for.
+ * @param info
+ * @return
+ */
+Napi::Value OdinRoom::GetOwnPeerId(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    uint64_t out_peer_id = 0;
+    odin_room_peer_id(this->_roomHandle, &out_peer_id);
+
+    return Napi::Number::New(env, out_peer_id);
+}