@4players/odin-nodejs 0.7.0

package/test.js

@@ -0,0 +1,211 @@
+const accessKey = "Ad4R7/hpCx1U5yGvC61oNBeJ/fWiW7dodvXWW7MEwrjg";
+const roomName = "Hallo";
+const userName = "My Bot";
+
+import odin from '../../index.cjs';
+const {OdinRoom, OdinClient} = odin;
+
+import wav from 'wav';
+import { Configuration, OpenAIApi } from "openai";
+import fs from 'fs';
+
+const configuration = new Configuration({
+    apiKey: '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'
+});
+const openai = new OpenAIApi(configuration);
+
+//const token = odin.generateAccessToken(accessKey, roomName, userName);
+//console.log(token);
+
+const userData = {
+    name: "Recorder Bot",
+    seed: "123",
+    userId: "Bot007",
+    outputMuted: 1,
+    platform: "ODIN JS Bot SDK",
+    version: "0.1"
+}
+
+const fileRecorder = {};
+
+const data = new TextEncoder().encode(JSON.stringify(userData));
+
+const odinClient = new OdinClient(accessKey);
+const room2 = odinClient.createRoom(roomName, userName);
+
+
+//odin.startup();
+
+//room2 = odin.initRoom(token);
+room2.setEventListener((event) => {
+    console.log(event);
+});
+
+room2.addEventListener('PeerJoined', (event) => {
+    console.log("Received PeerJoined event", event);
+    console.log(JSON.parse(new TextDecoder().decode(event.userData)));
+});
+
+room2.addEventListener('PeerLeft', (event) => {
+    console.log("Received PeerLeft event", event);
+});
+
+room2.addEventListener('MediaActivity', (event) => {
+    console.log("Media", event);
+    if (event.state) {
+        // User started talking
+        if (!fileRecorder[event.mediaId]) {
+            const timer = new Date().getTime();
+            const fileName = `./recording_${event.peerId}_${event.mediaId}_${timer}.wav`;
+            console.log(fileName);
+            fileRecorder[event.mediaId] = {
+                wavEncoder: new wav.FileWriter(fileName, {
+                    channels: 1,
+                    sampleRate: 48000,
+                    bitDepth: 16
+                }),
+                fileName: fileName
+            };
+        } else {
+            if (fileRecorder[event.mediaId].timer) {
+                clearTimeout(fileRecorder[event.mediaId].timer);
+                delete fileRecorder[event.mediaId].timer;
+            }
+        }
+    } else {
+        // User stopped talking
+        if (fileRecorder[event.mediaId]) {
+            if (!fileRecorder[event.mediaId].timer) {
+                fileRecorder[event.mediaId].timer = setTimeout(() => {
+                    fileRecorder[event.mediaId].wavEncoder.end();
+
+                    try {
+                        const file = fs.createReadStream(fileRecorder[event.mediaId].fileName);
+                        openai.createTranscription(file, "whisper-1").then((response) => {
+                            console.log("TRANSACTION", response.data.text);
+                        });
+                    } catch (e) {
+                        console.log("Failed to transcribe: ", e);
+                    }
+
+
+                    delete fileRecorder[event.mediaId];
+                }, 2000);
+            }
+        }
+    }
+});
+
+//const input = prompt('Press any key?');
+//const odinClient = new OdinClient(accessKey);
+//const room2 = new OdinRoom(token);
+
+room2.join("gateway.odin.4players.io", data);
+
+console.log("ROOM-ID:", room2.id);
+
+const message = {
+    kind: 'message',
+    payload: {
+        text: 'Hello World'
+    }
+}
+
+const fileWriter = new wav.FileWriter('./recording.wav', {
+    channels: 1,
+    sampleRate: 48000,
+    bitDepth: 16
+});
+
+room2.addEventListener('AudioDataReceived', (data) => {
+    //console.log("Received AudioDataReceived event from peer", data.peerId, "with mediaId", data.mediaId, "and event", data.samples32);
+    //console.log(Float32Array.from(data.samples32));
+
+    // Getting an array of the sample buffer
+    /*
+    let ui32 = new Float32Array(data.samples32.buffer);
+    console.log(ui32);
+
+    let ui16 = new Int16Array(data.samples16.buffer);
+    console.log(ui16);
+     */
+
+    fileWriter.file.write(data.samples16, (error) => {
+
+    });
+
+
+    if (fileRecorder[data.mediaId]) {
+        fileRecorder[data.mediaId].wavEncoder.file.write(data.samples16, (error) => {
+            if (error) {
+                console.log("Failed to write audio file");
+            }
+        });
+    }
+});
+
+room2.sendMessage(new TextEncoder().encode(JSON.stringify(message)));
+
+console.log("Press any key to stop");
+const stdin = process.stdin;
+stdin.resume();
+stdin.setEncoding( 'utf8' );
+stdin.on( 'data', function( key )
+{
+    console.log("Shutting down");
+    room2.close();
+    fileWriter.end();
+
+    process.exit();
+});
+
+
+
+/*
+const room = odin.createRoom();
+
+let error = 0;
+try {
+    error = odin.joinRoom(room, "gateway.odin.4players.io", token);
+} catch(e) {
+    console.log(error);
+    console.log(odin.formatError(error));
+}
+
+const userData = {
+    name: "Recorder Bot",
+    seed: "123",
+    userId: "Bot007",
+    outputMuted: 1,
+    platform: "ODIN JS Bot SDK",
+    version: "0.1"
+}
+
+const data = new TextEncoder().encode(JSON.stringify(userData));
+
+odin.updatePeerUserData(room, data);
+*/
+//const name = prompt('Press any key?');
+/*
+odin.closeRoom(room);
+odin.destroyRoom(room);
+odin.shutdown();
+*/
+/*
+
+const tokenGenerator = new TokenGenerator(accessKey);
+const token = tokenGenerator.createToken(roomName, userName);
+
+console.log(token);
+
+const testAddon = require('./build/Release/testaddon.node')
+console.log(testAddon.hello());
+console.log(testAddon.add(5,10));
+
+const classInstance = new testAddon.ClassExample(4.3);
+console.log('Testing class initial value : ',classInstance.getValue());
+console.log('After adding 3.3 : ',classInstance.add(3.3));
+
+const odinClient = new testAddon.OdinClient();
+odinClient.joinRoom(accessKey, roomName, userName);
+*/

package/tests/audio-recording/README.md

@@ -0,0 +1,24 @@
+# ODIN Node JS Sample "Audio Recording"
+
+This sample demonstrates how to use the ODIN SDK to record audio from other users and sending these to OpenAI for
+transcription. It also features basic "Bot" functionality like sending a message to the chat.
+
+## Prerequisites
+
+You need to have an ODIN Access Key. See [here](https://www.4players.io/odin/introduction/access-keys/#generating-access-keys))
+for more info on the topic and to create one for free directly in the documentation.
+
+This sample also requires an OpenAI API Key for transcription. You can get one for free [here](https://beta.openai.com/).
+
+## Getting Started
+
+Run the script with the following command:
+
+```bash
+node index.js
+```
+
+It will connect to the room `Lobby` using your access key and will send a "Hello World" message to the chat. It will 
+then wait for users start to talk and will record their audio into a file. The file name will be the user's name with a 
+timestamp and will be a WAV file. 2 seconds after the user stops talking, the recording will be stopped and the file
+will be sent to OpenAI for transcription.

package/tests/audio-recording/index.js

@@ -0,0 +1,148 @@
+const accessKey = "__YOUR_ACCESS_KEY__";
+const roomName = "Lobby";
+const userName = "My Bot";
+
+// Load the odin module
+import odin from '../../index.cjs';
+const {OdinClient} = odin;
+
+// Import wav module and OpenAI API
+import wav from 'wav';
+import { Configuration, OpenAIApi } from "openai";
+import fs from 'fs';
+
+// Configure OpenAI - use your own API key
+const configuration = new Configuration({
+    apiKey: '__YOUR_OPENAI_API_KEY__'
+});
+const openai = new OpenAIApi(configuration);
+
+// Create an odin client instance using our access key and create a room
+const odinClient = new OdinClient(accessKey);
+const room = odinClient.createRoom(roomName, userName);
+
+// Listen on PeerJoined messages and print the user data of the joined peer
+room.addEventListener('PeerJoined', (event) => {
+    console.log("Received PeerJoined event", event);
+    console.log(JSON.parse(new TextDecoder().decode(event.userData)));
+});
+
+// Listen on PeerLeft messages and print the user data of the left peer
+room.addEventListener('PeerLeft', (event) => {
+    console.log("Received PeerLeft event", event);
+});
+
+// Listen on MediaActivity messages and prepare a wav file for each media stream. The basic idea here is to
+// create a WAV encoder file whenever a users starts talking and to close the file when the user stops talking. This way,
+// we have isolated WAV files for each user and can transcribe them individually. If we don't want to create new files
+// during short pauses, we wait 2 seconds before closing the file.
+room.addEventListener('MediaActivity', (event) => {
+    if (event.state) {
+        // User started talking - prepare a new file
+        if (!fileRecorder[event.mediaId]) {
+            const timer = new Date().getTime();
+            const fileName = `./recording_${event.peerId}_${event.mediaId}_${timer}.wav`;
+            console.log("Created a new recording file: ", fileName);
+            fileRecorder[event.mediaId] = {
+                wavEncoder: new wav.FileWriter(fileName, {
+                    channels: 1,
+                    sampleRate: 48000,
+                    bitDepth: 16
+                }),
+                fileName: fileName
+            };
+        } else {
+            // We already have a file for this media stream - reset the timer to avoid closing the file
+            if (fileRecorder[event.mediaId].timer) {
+                clearTimeout(fileRecorder[event.mediaId].timer);
+                delete fileRecorder[event.mediaId].timer;
+            }
+        }
+    } else {
+        // User stopped talking
+        if (fileRecorder[event.mediaId]) {
+            // If we don't have a timer yet, create one
+            if (!fileRecorder[event.mediaId].timer) {
+                fileRecorder[event.mediaId].timer = setTimeout(() => {
+                    // The timer timed out - i.e. the user did stop talking for 2 seconds - close the file
+                    fileRecorder[event.mediaId].wavEncoder.end();
+
+                    // Transcribe the file using OpenAI
+                    try {
+                        const file = fs.createReadStream(fileRecorder[event.mediaId].fileName);
+                        openai.createTranscription(file, "whisper-1").then((response) => {
+                            console.log("OpenAI Transcription: ", response.data.text);
+                        });
+                    } catch (e) {
+                        console.log("Failed to transcribe: ", e);
+                    }
+
+                    // Delete the file recorder object
+                    delete fileRecorder[event.mediaId];
+                }, 2000);
+            }
+        }
+    }
+});
+
+// Configure user data used by the bot - this user data will be compatible with ODIN Web Client (https://odin.4players.de/app).
+const userData = {
+    name: "Recorder Bot",
+    seed: "123",
+    userId: "Bot007",
+    outputMuted: 1,
+    platform: "ODIN JS Bot SDK",
+    version: "0.1"
+}
+// Create a byte array from the user data (ODIN uses byte arrays for user data for maximum flexibility)
+const data = new TextEncoder().encode(JSON.stringify(userData));
+
+// Join the room using the default gateway and our user data
+room.join("gateway.odin.4players.io", data);
+
+// Print the room-id
+console.log("ROOM-ID:", room.id);
+
+// Add an event filter for audio data received events
+room.addEventListener('AudioDataReceived', (data) => {
+    // Getting an array of the sample buffer - use for example to visualize audio
+    /*
+    let ui32 = new Float32Array(data.samples32.buffer);
+    console.log(ui32);
+
+    let ui16 = new Int16Array(data.samples16.buffer);
+    console.log(ui16);
+     */
+
+    // Write the audio data to the file using a WAV encoder
+    if (fileRecorder[data.mediaId]) {
+        fileRecorder[data.mediaId].wavEncoder.file.write(data.samples16, (error) => {
+            if (error) {
+                console.log("Failed to write audio file");
+            }
+        });
+    }
+});
+
+// Prepare a message compatible with the ODIN Web Client and send it to all users (see @4players/odin-foundation for more info)
+const message = {
+    kind: 'message',
+    payload: {
+        text: 'Hello World'
+    }
+}
+room.sendMessage(new TextEncoder().encode(JSON.stringify(message)));
+
+// Wait for a key press to stop the script
+console.log("Press any key to stop");
+const stdin = process.stdin;
+stdin.resume();
+stdin.setEncoding( 'utf8' );
+stdin.on( 'data', function( key )
+{
+    console.log("Shutting down");
+    room.close();
+    fileWriter.end();
+
+    process.exit();
+});

package/tests/sending-audio/README.md

@@ -0,0 +1,20 @@
+# ODIN Send Music Example
+
+This sample demonstrates how to use the ODIN SDK to send music to other users in a room. It loads a sample MP3 file, 
+decodes it and sends it to the ODIN server. 
+
+## Prerequisites
+
+You need to have an ODIN Access Key. See [here](https://www.4players.io/odin/introduction/access-keys/#generating-access-keys))
+for more info on the topic and to create one for free directly in the documentation.
+
+## Getting Started
+
+Run the script with the following command:
+
+```bash
+node index.js
+```
+
+It will connect to the room `Lobby` using your access key and will send a "Hello World" message to the chat. It will then
+start sending an MP3 file into the room.

package/tests/sending-audio/index.js

@@ -0,0 +1,81 @@
+const accessKey = "__YOUR_ACCESS_KEY__";
+const roomName = "Lobby";
+const userName = "My Bot";
+
+// Load the odin module and other libs
+import odin from '../../index.cjs';
+const {OdinClient} = odin;
+import fs from 'fs';
+import decode, {decoders} from 'audio-decode';
+import AudioBufferStream from 'audio-buffer-stream';
+
+// Create an odin client instance using our access key and create a room
+const userData = {
+    name: "Music Bot",
+    avatar: "https://avatars.dicebear.com/api/bottts/123.svg?backgroundColor=%23333333&textureChance=0&margin=10",
+    seed: "123",
+    userId: "Bot007",
+    outputMuted: 1,
+    inputMuted: 0,
+    platform: "ODIN JS Bot SDK",
+    version: "0.1"
+}
+const data = new TextEncoder().encode(JSON.stringify(userData));
+const odinClient = new OdinClient(accessKey, 44100, 1);
+const room = odinClient.createRoom(roomName, userName);
+
+// Join the room
+room.join("gateway.odin.4players.io", data);
+
+// Send a message to the room
+const message = {
+    kind: 'message',
+    payload: {
+        text: 'Hello, I am a music bot and will stream some music to you.'
+    }
+}
+room.sendMessage(new TextEncoder().encode(JSON.stringify(message)));
+
+// Send music to the room
+const sendMusic = async (media) => {
+    // Prepare our MP3 decoder and load the sample file
+    const audioBuffer = await decode(fs.readFileSync('./santa.mp3'));
+
+    // Print our some info about the audio file
+    console.log(audioBuffer);
+
+    // Create a stream that will match the settings of the file
+    const audioBufferStream = new AudioBufferStream({channels: 1, sampleRate: 44100, float: true, bitDepth: 32});
+
+    // Whenever the stream has data, send it to the media stream
+    audioBufferStream.on('data', (data) => {
+        const floats = new Float32Array(new Uint8Array(data).buffer)
+        media.sendAudioData(floats);
+    });
+
+    audioBufferStream.write(audioBuffer);
+}
+
+// Create a media stream in the room - it will return an OdinMedia instance that we can use to send data to ODIN
+const media = room.createAudioStream(44100, 1);
+console.log(media);
+console.log("MEDIA-ID:", media.id);
+
+// Start the stream and send the music to ODIN
+sendMusic(media).then(() => {
+    console.log("Finished sending song");
+});
+
+// Wait until the user presses a key to stop
+console.log("Press any key to stop");
+const stdin = process.stdin;
+stdin.resume();
+stdin.setEncoding( 'utf8' );
+stdin.on( 'data', function( key )
+{
+    console.log("Shutting down");
+    room.close();
+
+    process.exit();
+});
+