@4players/odin-nodejs 0.10.3 → 0.11.1

package/index.cjs

@@ -1,2 +1,831 @@
 var binding = require('node-gyp-build')(__dirname);
+const { decode, encode } = require('@msgpack/msgpack');
+const { TokenGenerator } = require('@4players/odin-tokens');
+const NativeOdinRoom = binding.OdinRoom;
+const NativeOdinMedia = binding.OdinMedia;
+
+/**
+ * Event types emitted by OdinRoom:
+ * - RoomStatusChanged: { status: 'Connecting'|'Connected'|'Disconnected'|'Joining'|'Joined'|'Leaving'|'Closed', message?: string }
+ * - Joined: { room: Room, mediaIds: number[], ownPeerId: number }
+ * - Left: { reason: string }
+ * - RoomUserDataChanged: { userData: Uint8Array }
+ * - PeerJoined: { peer: Peer }
+ * - PeerLeft: { peerId: number }
+ * - PeerUserDataChanged: { peerId: number, userData: Uint8Array }
+ * - MediaStarted: { peerId: number, media: Media }
+ * - MediaStopped: { peerId: number, mediaId: number }
+ * - MediaActivity: { peerId: number, mediaId: number, state: boolean }
+ * - MessageReceived: { senderPeerId: number, message: Uint8Array } * - AudioDataReceived: { peerId: number, mediaId: number, samples16: Buffer, samples32: Buffer }
+ */
+
+class OdinRoomWrapper extends NativeOdinRoom {
+    constructor(token) {
+        super(token);
+        this._listeners = {};
+        this._connected = false;
+        this._ownPeerId = null;
+        this._roomId = null;
+        this._availableMediaIds = [];  // Store media IDs from Joined event
+        this._activeMediaStreams = []; // Track created media streams
+
+        // Listen to raw RPC bytes from native layer
+        super.setEventListener((data) => this._onRPC(data));
+    }
+
+    /**
+     * Parse incoming RPC messages (MessagePack format)
+     * Format: [type, eventName, eventData] where type=2 for notifications
+     */
+    _onRPC(data) {
+        if (!data || !(data instanceof ArrayBuffer)) return;
+
+        try {
+            const bytes = new Uint8Array(data);
+            const rpc = decode(bytes);
+
+            if (!Array.isArray(rpc) || rpc.length < 3) return;
+
+            const [type, eventName, eventData] = rpc;
+
+            // Type 2 = Notification
+            if (type === 2) {
+                this._handleEvent(eventName, eventData);
+            }
+            // Type 1 = Response (for commands)
+            else if (type === 1) {
+                // Handle command responses if needed
+            }
+        } catch (e) {
+            console.error('Failed to parse RPC:', e);
+        }
+    }
+
+    /**
+     * Handle different event types
+     */
+    _handleEvent(eventName, eventData) {
+        switch (eventName) {
+            case 'RoomStatusChanged':
+                this._handleRoomStatusChanged(eventData);
+                break;
+            case 'RoomUpdated':
+                this._handleRoomUpdated(eventData);
+                break;
+            case 'PeerUpdated':
+                this._handlePeerUpdated(eventData);
+                break;
+            case 'MessageReceived':
+                this._handleMessageReceived(eventData);
+                break;
+            default:
+                // Emit raw event for any unknown types
+                this._emit(eventName, eventData);
+        }
+    }
+
+    /**
+     * Handle RoomStatusChanged events
+     */
+    _handleRoomStatusChanged(data) {
+        const status = data.status;
+        const message = data.message;
+
+        this._emit('RoomStatusChanged', { status, message });
+
+        // Also emit connection state for convenience
+        this._emit('ConnectionStateChanged', { state: status, message });
+
+        if (status === 'Joined') {
+            this._connected = true;
+        } else if (status === 'Closed' || status === 'Disconnected') {
+            this._connected = false;
+        }
+    }
+
+    /**
+     * Handle RoomUpdated events which contain multiple update types
+     */
+    _handleRoomUpdated(data) {
+        if (!data.updates || !Array.isArray(data.updates)) return;
+
+        for (const update of data.updates) {
+            const kind = update.kind;
+
+            switch (kind) {
+                case 'Joined':
+                    this._connected = true;
+                    this._ownPeerId = update.own_peer_id;
+                    // Inform native layer of own peer ID
+                    if (update.own_peer_id != null) {
+                        super.setOwnPeerId(update.own_peer_id);
+                    }
+                    // Store available media IDs for auto-selection
+                    this._availableMediaIds = update.media_ids ? [...update.media_ids] : [];
+                    // Emit Joined event (matches core SDK naming)
+                    this._emit('Joined', {
+                        roomId: update.room?.id,
+                        ownPeerId: update.own_peer_id,
+                        room: update.room,
+                        mediaIds: update.media_ids
+                    });
+                    // Emit PeerJoined for existing peers and register their media
+                    if (update.room?.peers) {
+                        for (const peer of update.room.peers) {
+                            this._emit('PeerJoined', {
+                                peerId: peer.id,
+                                peer: peer,
+                                userId: peer.user_id,
+                                userData: peer.user_data
+                            });
+                            // Register existing media for this peer in native layer
+                            if (peer.medias) {
+                                for (const media of peer.medias) {
+                                    super.registerMediaPeer(media.id, peer.id);
+                                }
+                            }
+                        }
+                    }
+                    break;
+
+                case 'Left':
+                    this._connected = false;
+                    // Emit Left event (matches core SDK naming)
+                    this._emit('Left', { roomId: this._roomId, reason: update.reason });
+                    break;
+
+                case 'UserDataChanged':
+                    this._emit('RoomUserDataChanged', { userData: update.user_data });
+                    break;
+
+                case 'PeerJoined':
+                    this._emit('PeerJoined', {
+                        peerId: update.peer?.id,
+                        peer: update.peer,
+                        userId: update.peer?.user_id,
+                        userData: update.peer?.user_data
+                    });
+                    break;
+
+                case 'PeerLeft':
+                    this._emit('PeerLeft', { peerId: update.peer_id });
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Handle PeerUpdated events
+     */
+    _handlePeerUpdated(data) {
+        const kind = data.kind;
+
+        switch (kind) {
+            case 'UserDataChanged':
+                this._emit('PeerUserDataChanged', {
+                    peerId: data.peer_id,
+                    userData: data.user_data
+                });
+                break;
+
+            case 'MediaStarted':
+                // Register media-to-peer mapping in native layer for audio data events
+                if (data.media?.id != null && data.peer_id != null) {
+                    super.registerMediaPeer(data.media.id, data.peer_id);
+                }
+                this._emit('MediaStarted', {
+                    peerId: data.peer_id,
+                    media: data.media
+                });
+                // Legacy MediaAdded event
+                this._emit('MediaAdded', {
+                    peerId: data.peer_id,
+                    mediaId: data.media?.id
+                });
+                break;
+
+            case 'MediaStopped':
+                // Unregister media from native layer
+                if (data.media_id != null) {
+                    super.unregisterMedia(data.media_id);
+                }
+                this._emit('MediaStopped', {
+                    peerId: data.peer_id,
+                    mediaId: data.media_id
+                });
+                // Legacy MediaRemoved event
+                this._emit('MediaRemoved', {
+                    peerId: data.peer_id,
+                    mediaId: data.media_id
+                });
+                break;
+
+            case 'TagsChanged':
+                this._emit('PeerTagsChanged', {
+                    peerId: data.peer_id,
+                    tags: data.tags
+                });
+                break;
+
+            case 'MediaActivity':
+                this._emit('MediaActivity', {
+                    peerId: data.peer_id,
+                    mediaId: data.media_id,
+                    state: data.state
+                });
+                break;
+        }
+    }
+
+    /**
+     * Handle MessageReceived events
+     */
+    _handleMessageReceived(data) {
+        this._emit('MessageReceived', {
+            senderPeerId: data.sender_peer_id,
+            message: data.message
+        });
+    }
+
+    /**
+     * Emit an event to registered listeners
+     */
+    _emit(event, data) {
+        if (this._listeners[event]) {
+            this._listeners[event].forEach(cb => {
+                try { cb(data); } catch (e) { console.error(e); }
+            });
+        }
+    }
+
+    /**
+     * Add an event listener
+     * @param {string} event - Event name
+     * @param {Function} callback - Callback function
+     */
+    addEventListener(event, callback) {
+        // AudioDataReceived goes directly to native
+        if (event === "AudioDataReceived") {
+            return super.addEventListener(event, callback);
+        }
+        if (!this._listeners[event]) this._listeners[event] = [];
+        this._listeners[event].push(callback);
+    }
+
+    /**
+     * Remove an event listener
+     * @param {string} event - Event name
+     * @param {Function} [callback] - Optional specific callback to remove
+     */
+    removeEventListener(event, callback) {
+        if (event === "AudioDataReceived") {
+            return super.removeEventListener(event);
+        }
+        if (callback && this._listeners[event]) {
+            this._listeners[event] = this._listeners[event].filter(cb => cb !== callback);
+        } else {
+            delete this._listeners[event];
+        }
+    }
+
+    /**
+     * Convenience method: Set handler for when room is joined
+     * @param {Function} handler - Handler receiving { roomId, ownPeerId, room }
+     */
+    onJoined(handler) {
+        this.addEventListener('Joined', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for when room is left
+     * @param {Function} handler - Handler receiving { reason }
+     */
+    onLeft(handler) {
+        this.addEventListener('Left', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for peer joined events
+     * @param {Function} handler - Handler receiving { peerId, peer, userId, userData }
+     */
+    onPeerJoined(handler) {
+        this.addEventListener('PeerJoined', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for peer left events  
+     * @param {Function} handler - Handler receiving { peerId }
+     */
+    onPeerLeft(handler) {
+        this.addEventListener('PeerLeft', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for media started events
+     * @param {Function} handler - Handler receiving { peerId, media }
+     */
+    onMediaStarted(handler) {
+        this.addEventListener('MediaStarted', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for media stopped events
+     * @param {Function} handler - Handler receiving { peerId, mediaId }
+     */
+    onMediaStopped(handler) {
+        this.addEventListener('MediaStopped', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for message received events
+     * @param {Function} handler - Handler receiving { senderPeerId, message }
+     */
+    onMessageReceived(handler) {
+        this.addEventListener('MessageReceived', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for connection state changes
+     * @param {Function} handler - Handler receiving { state, message }
+     */
+    onConnectionStateChanged(handler) {
+        this.addEventListener('ConnectionStateChanged', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for audio data events
+     * @param {Function} handler - Handler receiving { peerId, mediaId, samples16, samples32 }
+     */
+    onAudioDataReceived(handler) {
+        this.addEventListener('AudioDataReceived', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for peer user data changed events
+     * @param {Function} handler - Handler receiving { peerId, userData }
+     */
+    onPeerUserDataChanged(handler) {
+        this.addEventListener('PeerUserDataChanged', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for room user data changed events
+     * @param {Function} handler - Handler receiving { userData }
+     */
+    onRoomUserDataChanged(handler) {
+        this.addEventListener('RoomUserDataChanged', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for media activity events (voice activity)
+     * @param {Function} handler - Handler receiving { peerId, mediaId, state }
+     */
+    onMediaActivity(handler) {
+        this.addEventListener('MediaActivity', handler);
+    }
+
+    /**
+     * Convenience method: Set handler for peer tags changed events
+     * @param {Function} handler - Handler receiving { peerId, tags }
+     */
+    onPeerTagsChanged(handler) {
+        this.addEventListener('PeerTagsChanged', handler);
+    }
+
+    /**
+     * Closes the room connection and releases all resources.
+     * 
+     * This method emits the 'Left' event before closing the native connection,
+     * ensuring that cleanup callbacks registered via onLeft() are triggered
+     * regardless of whether the disconnect is client-initiated (via close()) or
+     * server-initiated. This provides a single, consistent cleanup path for
+     * session state management.
+     * 
+     * The reason provided in the Left event will be 'ClientDisconnect' to
+     * distinguish it from server-initiated disconnects.
+     */
+    close() {
+        // Only emit Left if we're currently connected
+        // This avoids duplicate events if the server also sent a Left update
+        if (this._connected) {
+            this._connected = false;
+            // Emit Left event with a reason indicating client-initiated disconnect
+            this._emit('Left', { roomId: this._roomId, reason: 'ClientDisconnect' });
+        }
+        // Close all active media streams before closing the room
+        for (const media of this._activeMediaStreams) {
+            try {
+                media.close();
+            } catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+        this._activeMediaStreams = [];
+        // Call native close
+        super.close();
+    }
+
+    /**
+     * Get current connection state
+     */
+    get connected() {
+        return this._connected;
+    }
+
+    /**
+     * Get own peer ID (available after joining)
+     */
+    get ownPeerId() {
+        return this._ownPeerId;
+    }
+
+    /**
+     * Get available media IDs (populated after Joined event)
+     */
+    get availableMediaIds() {
+        return [...this._availableMediaIds];
+    }
+
+    /**
+     * Claim the next available media ID for a new stream.
+     * @returns {number|null} The claimed media ID, or null if none available
+     * @private
+     */
+    _claimMediaId() {
+        if (this._availableMediaIds.length === 0) return null;
+        return this._availableMediaIds.shift();
+    }
+
+    /**
+     * Return a media ID to the available pool (when stream is closed).
+     * @param {number} mediaId - The media ID to return
+     * @private
+     */
+    _returnMediaId(mediaId) {
+        if (mediaId && !this._availableMediaIds.includes(mediaId)) {
+            this._availableMediaIds.push(mediaId);
+        }
+    }
+
+    /**
+     * Creates a new audio stream for sending audio data.
+     * Returns a wrapped OdinMedia instance with convenience methods.
+     * @param {number} sampleRate - The sample rate (e.g., 48000, 44100)
+     * @param {number} channels - Number of channels (1 or 2)
+     * @param {object} [apmSettings] - Optional APM settings
+     * @returns {OdinMediaWrapper} The wrapped media stream
+     */
+    createAudioStream(sampleRate, channels, apmSettings) {
+        // Call native createAudioStream to get native media object
+        const nativeMedia = super.createAudioStream(sampleRate, channels, apmSettings);
+        // Wrap it with JS convenience layer
+        const wrapper = new OdinMediaWrapper(nativeMedia, this, sampleRate, channels);
+        this._activeMediaStreams.push(wrapper);
+        return wrapper;
+    }
+}
+
+/**
+ * OdinMediaWrapper provides a high-level API for sending audio to ODIN rooms.
+ * 
+ * It wraps the native OdinMedia object and adds convenience methods like sendMP3,
+ * sendWAV, and sendBuffer that handle all the setup (media ID, StartMedia RPC,
+ * timing) automatically.
+ * 
+ * Low-level API (manual control):
+ *   media.setMediaId(id);  // From Joined event
+ *   media.start();
+ *   media.sendAudioData(chunk);  // Each 20ms chunk
+ *   media.stop();
+ *   media.close();
+ * 
+ * High-level API (convenience):
+ *   await media.sendMP3('./file.mp3');   // Auto handles everything
+ *   await media.sendWAV('./file.wav');
+ *   await media.sendBuffer(audioBuffer);
+ * 
+ * Note: start() and stop() methods have been removed as they were not
+ * needed - they matched a pattern that doesn't exist in the core SDK.
+ * Just call sendAudioData() to send audio, and close() when done.
+ */
+class OdinMediaWrapper {
+    /**
+     * Creates a new OdinMediaWrapper.
+     * @param {object} nativeMedia - The native OdinMedia object
+     * @param {OdinRoomWrapper} room - The parent room wrapper
+     * @param {number} sampleRate - Sample rate in Hz
+     * @param {number} channels - Number of channels (1 or 2)
+     */
+    constructor(nativeMedia, room, sampleRate, channels) {
+        this._native = nativeMedia;
+        this._room = room;
+        this._sampleRate = sampleRate;
+        this._channels = channels;
+        this._mediaId = null;
+        this._rpcSent = false;  // Track if StartMedia RPC was sent (for convenience API)
+        this._closed = false;
+    }
+
+    // ========== Native method proxies ==========
+
+    /** Get the media ID for this stream */
+    get id() {
+        if (this._closed || !this._native) return null;
+        return this._native.id;
+    }
+
+    /** Check if this media stream has been closed */
+    get closed() {
+        return this._closed;
+    }
+
+    /**
+     * Set the server-assigned media ID.
+     * This must be called before sending audio data.
+     * 
+     * @param {number} mediaId - From Joined event's mediaIds array
+     * @returns {OdinMediaWrapper} This instance for chaining
+     */
+    setMediaId(mediaId) {
+        if (this._closed) return this;
+        this._mediaId = mediaId;
+        if (this._native && typeof this._native.setMediaId === 'function') {
+            this._native.setMediaId(mediaId);
+        }
+        return this;
+    }
+
+    /** 
+     * Close and release the media stream.
+     * Sends a StopMedia RPC to notify the server, then frees local resources.
+     * After calling this, the media stream cannot be used.
+     */
+    close() {
+        if (this._closed) return;
+        this._closed = true;
+
+        // Send StopMedia RPC if we previously sent StartMedia
+        // This notifies the server that the media has stopped
+        if (this._rpcSent && this._mediaId && this._room) {
+            try {
+                const rpc = encode([0, 1, "StopMedia", { media_id: this._mediaId }]);
+                this._room.sendRpc(new Uint8Array(rpc));
+            } catch (e) {
+                // Ignore errors during cleanup (room may be closing)
+            }
+        }
+
+        // Return media ID to pool
+        if (this._mediaId && this._room) {
+            try {
+                this._room._returnMediaId(this._mediaId);
+            } catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+        this._mediaId = null;
+        this._rpcSent = false;
+
+        // Call native close
+        if (this._native) {
+            try {
+                this._native.close();
+            } catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+
+        // Clear references
+        this._native = null;
+        this._room = null;
+    }
+
+    /**
+     * Send raw audio samples.
+     * @param {Float32Array} samples - Interleaved audio samples in range [-1, 1]
+     */
+    sendAudioData(samples) {
+        if (this._closed || !this._native) return;
+        return this._native.sendAudioData(samples);
+    }
+
+    // ========== Convenience methods ==========
+
+    /**
+     * Ensures the stream is set up for the convenience API.
+     * Auto-claims media ID and sends StartMedia RPC if not done yet.
+     * @private
+     */
+    async _ensureStarted() {
+        if (this._rpcSent) return;
+        if (this._closed) throw new Error('Media stream has been closed');
+
+        // Claim a media ID if not already set
+        if (!this._mediaId) {
+            this._mediaId = this._room._claimMediaId();
+            if (!this._mediaId) {
+                throw new Error('No available media IDs. Wait for Joined event before sending audio.');
+            }
+            // Set on native binding
+            if (this._native && typeof this._native.setMediaId === 'function') {
+                this._native.setMediaId(this._mediaId);
+            }
+        }
+
+        // Send StartMedia RPC to notify the server
+        const rpc = encode([0, 1, "StartMedia", {
+            media_id: this._mediaId,
+            properties: { kind: "audio" }
+        }]);
+        if (this._room) {
+            this._room.sendRpc(new Uint8Array(rpc));
+        }
+
+        this._rpcSent = true;
+    }
+
+    /**
+     * Send an MP3 file with automatic decoding and real-time streaming.
+     * Handles all setup (media ID, StartMedia RPC, timing) automatically.
+     * 
+     * @param {string} filePath - Path to the MP3 file
+     * @returns {Promise<void>} Resolves when audio streaming is complete
+     */
+    async sendMP3(filePath) {
+        await this._ensureStarted();
+        return this._streamAudioFile(filePath);
+    }
+
+    /**
+     * Send a WAV file with automatic decoding and real-time streaming.
+     * Handles all setup (media ID, StartMedia RPC, timing) automatically.
+     * 
+     * @param {string} filePath - Path to the WAV file
+     * @returns {Promise<void>} Resolves when audio streaming is complete
+     */
+    async sendWAV(filePath) {
+        await this._ensureStarted();
+        return this._streamAudioFile(filePath);
+    }
+
+    /**
+     * Send an AudioBuffer with real-time streaming.
+     * Handles all setup (media ID, StartMedia RPC, timing) automatically.
+     * 
+     * @param {AudioBuffer} audioBuffer - Decoded audio from audio-decode
+     * @returns {Promise<void>} Resolves when audio streaming is complete
+     */
+    async sendBuffer(audioBuffer) {
+        await this._ensureStarted();
+        return this._streamBuffer(audioBuffer);
+    }
+
+    /**
+     * Decode and stream an audio file.
+     * @param {string} filePath - Path to the audio file
+     * @private
+     */
+    async _streamAudioFile(filePath) {
+        const fs = require('fs');
+        // audio-decode is an ESM module, but we can use dynamic import
+        const audioDecode = await import('audio-decode');
+        const decode = audioDecode.default || audioDecode;
+        const audioBuffer = await decode(fs.readFileSync(filePath));
+        return this._streamBuffer(audioBuffer);
+    }
+
+    /**
+     * Stream an AudioBuffer with proper timing (20ms chunks).
+     * Includes guards to stop streaming if the media is closed during playback.
+     * @param {AudioBuffer} audioBuffer - The decoded audio
+     * @private
+     */
+    async _streamBuffer(audioBuffer) {
+        // Early exit if already closed
+        if (this._closed) return;
+
+        const numChannels = this._channels;
+        const sampleRate = audioBuffer.sampleRate;
+
+        // Get interleaved audio data
+        let audioData;
+        if (numChannels === 2 && audioBuffer.numberOfChannels >= 2) {
+            const left = audioBuffer.getChannelData(0);
+            const right = audioBuffer.getChannelData(1);
+            audioData = new Float32Array(left.length * 2);
+            for (let i = 0; i < left.length; i++) {
+                audioData[i * 2] = left[i];
+                audioData[i * 2 + 1] = right[i];
+            }
+        } else {
+            audioData = audioBuffer.getChannelData(0);
+        }
+
+        // 20ms chunks at source sample rate
+        const chunkDurationMs = 20;
+        const samplesPerChunk = Math.floor(sampleRate * chunkDurationMs / 1000);
+        const floatsPerChunk = samplesPerChunk * numChannels;
+
+        // Split into chunks
+        const chunks = [];
+        for (let offset = 0; offset < audioData.length; offset += floatsPerChunk) {
+            const end = Math.min(offset + floatsPerChunk, audioData.length);
+            chunks.push(audioData.slice(offset, end));
+        }
+
+        // Send chunks with precise timing
+        const startTime = Date.now();
+        for (let i = 0; i < chunks.length; i++) {
+            // Check if closed before each chunk to allow early termination
+            if (this._closed) return;
+
+            // Use the guarded sendAudioData method instead of calling native directly
+            this.sendAudioData(chunks[i]);
+
+            // Calculate when the next chunk should be sent
+            const nextChunkTime = startTime + (i + 1) * chunkDurationMs;
+            const now = Date.now();
+            const waitTime = nextChunkTime - now;
+
+            if (waitTime > 0 && i < chunks.length - 1) {
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+    }
+}
+
+const NativeOdinClient = binding.OdinClient;
+
+/**
+ * JavaScript wrapper for OdinClient that ensures rooms are created
+ * with the full JavaScript wrapper (OdinRoomWrapper) instead of native objects.
+ */
+class OdinClientWrapper extends NativeOdinClient {
+    constructor() {
+        super();
+    }
+
+    /**
+     * Create a room with the given token.
+     * @param {string} token - The authentication token
+     * @returns {OdinRoomWrapper} A wrapped room instance with event handling
+     */
+    createRoom(token) {
+        return new OdinRoomWrapper(token);
+    }
+
+    /**
+     * Creates a new local room instance with the given room token. Use `join` on the returned OdinRoom instance to
+     * connect to that room. Use this method if you already have an access token, either created elsewhere or by calling
+     * `generateAccessToken`.
+     * @param {string} token - The access token to use to join the room.
+     */
+    createRoomWithToken(token) {
+        return new OdinRoomWrapper(token);
+    }
+
+    /**
+     * Generates a room token for the given access key, room and user ID. This token can be used to join the room.
+     * @param {string} accessKey - The access key to use to generate the token. You can get a free access token in our developer center
+     * @param {string} roomId - The ID of the room to generate the token for.
+     * @param {string} userId - The ID of the user to generate the token for.
+     * @returns {string} The generated token
+     */
+    generateToken(accessKey, roomId, userId) {
+        const generator = new TokenGenerator(accessKey);
+        return generator.createToken(roomId, userId);
+    }
+
+    /**
+     * Generates a token for the given access key, room and user ID. This token can be used to join the room.
+     * To be more consistent with other SDKs, this method is deprecated. Use generateToken instead.
+     * @param {string} accessKey - The access key to use to generate the token. You can get a free access token in our developer center
+     * @param {string} roomId - The ID of the room to generate the token for.
+     * @param {string} userId - The ID of the user to generate the token for.
+     * @returns {string} The generated token
+     * @deprecated Use generateToken instead
+     */
+    generateAccessToken(accessKey, roomId, userId) {
+        return this.generateToken(accessKey, roomId, userId);
+    }
+}
+
+/**
+ * Generates an access token for a room and user ID.
+ * @param {string} accessKey - The access key to use to generate the token.
+ * @param {string} roomId - The ID of the room to generate the token for.
+ * @param {string} userId - The ID of the user to generate the token for.
+ * @returns {string} The generated token
+ * @deprecated Use OdinClient.generateToken instead.
+ */
+function generateAccessToken(accessKey, roomId, userId) {
+    const generator = new TokenGenerator(accessKey);
+    return generator.createToken(roomId, userId);
+}
+
+binding.OdinRoom = OdinRoomWrapper;
+binding.OdinMedia = OdinMediaWrapper;
+binding.OdinClient = OdinClientWrapper;
+binding.generateAccessToken = generateAccessToken;
+
 module.exports = binding;