How to import javascript into node.js desktop application

With the growth of web applications, JavaScript has become one of the most popular programming languages ​​for development. However, as technology advances, JavaScript is no longer limited to development in a web browser environment. Now, we can use JavaScript to build rich desktop applications. One possible way is to use Node.js.

Node.js is an open source JavaScript runtime environment for building efficient and scalable web and server-side applications. It is cross-platform and has a powerful modular system that helps developers build desktop applications easily.

With Node.js, we can use the Electron framework to build cross-platform desktop applications. Electron uses Node.js and Chromium as its foundation, allowing developers to build desktop applications using web technologies such as HTML, CSS, and JavaScript.

In this article, we will introduce how to use Node.js and the Electron framework to build desktop applications, including how to implement the function of entering N code.

Creating Electron Application

First, we need to make sure Node.js is installed on our computer. Next, let's start creating an Electron application. We will use npm, the package manager for Node.js, to create a new Electron project.

Open a terminal and enter the following command:

npm init -y

This will create a new Node.js project. Now, install Electron dependencies:

npm install electron --save-dev

Now, create a main.js file as your main process file. This file will contain the logic for your application:

const { app, BrowserWindow } = require('electron');

function createWindow() {
  const win = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      nodeIntegration: true
    }
  });

  win.loadFile('index.html');

  win.webContents.openDevTools();
}

app.whenReady().then(() => {
  createWindow();

  app.on('activate', function () {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

app.on('window-all-closed', function () {
  if (process.platform !== 'darwin') app.quit();
});

The above code will create a window and load the index.html file into the window. Of course, at this point our application has no interface. Next, we will create an HTML file for interface design and JavaScript code writing.

To show how to record the N code, please create a new HTML file and add the following content:

nbsp;html>


  <meta>
  <title>N Code Recorder</title>


  <h1 id="N-Code-Recorder">N Code Recorder</h1>

  <textarea></textarea>
  <br>
  <button>Record</button>
  <button>Stop</button>

  <script></script>

In this HTML file, we added a text area for entering the N code, And added a record button and a stop button. At the same time, we also added a JavaScript file for front-end interactive logic implementation.

Implementing the recording function of N code

Next, we will create JavaScript code for controlling the record button and stop button. Create a JavaScript file named renderer.js in the root directory of the project and add the following code:

const { desktopCapturer } = require('electron');

const codeInput = document.getElementById('code-input');
const recordButton = document.getElementById('record-button');
const stopButton = document.getElementById('stop-button');

let mediaRecorder;
const recordedChunks = [];

recordButton.onclick = async () => {
  try {
    const inputSources = await desktopCapturer.getSources({ types: ['window', 'screen'] });

    const selectedSource = await selectSource(inputSources);

    const stream = await navigator.mediaDevices.getUserMedia({
      audio: false,
      video: {
        mandatory: {
          chromeMediaSource: 'desktop',
          chromeMediaSourceId: selectedSource.id,
        }
      }
    });

    mediaRecorder = new MediaRecorder(stream, { mimeType: 'video/webm; codecs=vp9' });

    mediaRecorder.ondataavailable = handleDataAvailable;
    mediaRecorder.start();

    recordButton.style.background = 'red';
  } catch (e) {
    console.log(e);
  }
}

stopButton.onclick = () => {
  mediaRecorder.stop();
  recordButton.style.background = '';
}

function handleDataAvailable(event) {
  console.log('data-available');
  recordedChunks.push(event.data);
}

async function selectSource(inputSources) {
  return new Promise((resolve, reject) => {
    const options = inputSources.map(source => {
      return {
        label: source.name,
        value: source,
      };
    });

    const dropdown = document.createElement('select');
    dropdown.className = 'form-control';
    options.forEach(option => {
      const element = document.createElement('option');
      element.label = option.label;
      element.value = option.value.id;
      dropdown.appendChild(element);
    });

    dropdown.onchange = () => resolve(options[dropdown.selectedIndex].value);

    document.body.appendChild(dropdown);
  });
}

Now, we have implemented the logic of the record and stop buttons in JavaScript code. When the user presses the record button, we use the desktopCapturer API to get the stream from the screenshot selected by the user. We instantiate the media recorder using the MediaRecorder API and push the received data fragments into an array. When the user presses the stop button, we call the stop method of MediaRecorder to stop recording. The data received will be used for future N-code translation.

N Transcoder

Now we have created the JavaScript code for recording and stopping the media stream. Next, we will introduce how to use an open source online media converter to convert recorded media streams to N-code.

We can use the open source Web media converter CloudConvert to convert media streams to N-code. CloudConvert provides a REST API that helps us easily convert media streams or files to other formats like N-code. To do this, we need to install the cloudconvert package in the project.

Open a terminal and enter the following command:

npm install cloudconvert --save

Next, we will use CloudConvert’s REST API to convert the recorded media stream to N-code and add it to our application.

const cloudconvert = require('cloudconvert');

const apikey = 'YOUR_API_KEY';
const input = 'webm';
const output = 'n';

const convertStream = cloudconvert.convert({
  apiKey: apikey,
  inputformat: input,
  outputformat: output,
});

recordButton.onclick = async () => {
  try {
    // ...

    mediaRecorder.onstop = () => {
      console.log('mediaRecorder.onstop', recordedChunks);

      const blob = new Blob(recordedChunks, {
        type: 'video/webm; codecs=vp9'
      });

      const reader = new FileReader();

      reader.readAsArrayBuffer(blob);

      reader.onloadend = async () => {
        const buffer = Buffer.from(reader.result);

        await convertStream.start({
          input: 'upload',
          inputformat: input,
          file: buffer.toString('base64'),
        });

        const links = await convertStream.getLinks();

        console.log(links);
        codeInput.value = links[output];
      };

      recordedChunks.length = 0;
    };

    // ...
  } catch (e) {
    console.log(e);
  }
}

In the above code, we set the apiKey, input format and output format of the cloud conversion API as variables. After recording the media stream, we push the data into the recordedChunks array, then use the Blob API to create a Blob object containing the recorded data, and use the FileReader API to read the BLOB data. Once we obtain the blob data, we convert it to Base64 format using the Buffer API and then submit the Base64-encoded recording data for conversion using CloudConvert’s REST API.

Finally, we add the converted N code to the UI of the application.

Conclusion

In this article, we covered how to create a desktop application using Node.js and the Electron framework, and how to convert recorded data using JavaScript and the Cloud Conversion API. Media streams are converted to N-code. Finally, we show how to add the converted N-code to the application's UI.

Desktop applications can be easily built using Node.js and the Electron framework, while JavaScript and other open source libraries can make desktop application implementation simpler and easier. Using the cloud conversion API can provide us with powerful media conversion capabilities. I hope this article helped you learn how to build feature-rich desktop applications.

The above is the detailed content of How to import javascript into node.js desktop application. For more information, please follow other related articles on the PHP Chinese website!