Webpack practical construction Electron application examples detailed explanation

Electron allows you to use Web development technology to develop cross-platform desktop applications. It is led and open sourced by Github. The familiar Atom and VSCode editors are developed using Electron. This article mainly introduces the practical use of Webpack to build Electron applications. The editor thinks it is quite good, so I will share it with you now and give it as a reference. Let’s follow the editor to take a look, I hope it can help everyone.

Electron is a combination of Node.js and the Chromium browser. It uses the Web page displayed by the Chromium browser as the GUI of the application and interacts with the operating system through Node.js. When you operate on a window in an Electron application, you are actually operating on a web page. When your operation needs to be completed through the operating system, the web page will interact with the operating system through Node.js.

The advantages of developing desktop applications in this way are:

1. Lower the development threshold, you only need to master web development technology and Node.js, a large number of Web Development technologies and ready-made libraries can be reused in Electron;

2. Since the Chromium browser and Node.js are both cross-platform, Electron can write the same code on different operating systems. run.

When running an Electron application, it starts by starting a main process. The startup of the main process is achieved by executing an entry JavaScript file through Node.js. The content of this entry file main.js is as follows:

##

const { app, BrowserWindow } = require('electron')
// 保持一个对于 window 对象的全局引用，如果你不这样做，
// 当 JavaScript 对象被垃圾回收， window 会被自动地关闭
let win
// 打开主窗口
function createWindow() {
 // 创建浏览器窗口
 win = new BrowserWindow({ width: 800, height: 600 })
 // 加载应用的 index.html
 const indexPageURL = `file://${__dirname}/dist/index.html`;
 win.loadURL(indexPageURL);
 // 当 window 被关闭，这个事件会被触发
 win.on('closed', () => {
  // 取消引用 window 对象
  win = null
 })
}

// Electron 会在创建浏览器窗口时调用这个函数。
app.on('ready', createWindow)

// 当全部窗口关闭时退出
app.on('window-all-closed', () => {
 // 在 macOS 上，除非用户用 Cmd + Q 确定地退出
 // 否则绝大部分应用会保持激活
 if (process.platform !== 'darwin') {
  app.quit()
 }
})

The main process will remain resident after it is started. If you leave it running in the background, the window you see and operate is not the main process, but the window sub-process newly started by the main process.

The application has a series of life cycle events from startup to exit. Use the electron.app.on() function to monitor life cycle events and react at specific moments. For example, use BrowserWindow to display the main window of the application in the app.on('ready') event.

The window that is started is actually a web page. When it is started, it will load the web page address passed in loadURL. Each window is a separate web page process, and communication between windows requires the use of the main process to pass messages.

Generally speaking, developing Electron applications is very similar to developing Web applications. The difference is that the Electron operating environment has built-in browsers and Node.js APIs. When developing web pages, In addition to using the API provided by the browser, you can also use the API provided by Node.js.

Connect to Webpack

Next, make a simple Electron application. It is required to display a main window after the application is started. There is a button in the main window. Click this A new window is displayed after the button, and React is used to develop the web page.

Since each window in the Electron application corresponds to a web page, two web pages need to be developed, namely the index.html of the main window and the newly opened window login.html. In other words, the project consists of 2 single-page applications, which is very similar to the project in 3-10 Managing Multiple Single-page Applications. Let's transform it into an Electron application.

The places that need to be changed are as follows:

Create a new entry file main.js for the main process in the project root directory, the content is consistent with the above mentioned;

The code of the main window web page is as follows:

import React, { Component } from 'react';
import { render } from 'react-dom';
import { remote } from 'electron';
import path from 'path';
import './index.css';
class App extends Component {
 // 在按钮被点击时
 handleBtnClick() {
  // 新窗口对应的页面的 URI 地址
  const modalPath = path.join('file://', remote.app.getAppPath(), 'dist/login.html');
  // 新窗口的大小
  let win = new remote.BrowserWindow({ width: 400, height: 320 })
  win.on('close', function () {
   // 窗口被关闭时清空资源
   win = null
  })
  // 加载网页
  win.loadURL(modalPath)
  // 显示窗口
  win.show()
 }
 render() {
  return (
   <p>
    <h1>Page Index</h1>
    <button onClick={this.handleBtnClick}>Open Page Login</button>
   </p>
  )
 }
}
render(<App/>, window.document.getElementById(&#39;app&#39;));

The most critical part is to open a new window through the API provided by the electron library in the button click event. And load the address where the web page file is located.

The code of the page part has been modified. Next, modify the construction code. The construction here needs to do the following:

Build two web pages that can be run in the browser, corresponding to the interfaces of the two windows;

1. Since in The JavaScript code of the web page may call the Node.js native module or electron module, that is, the output code depends on these modules. However, since these modules have built-in support, the built code cannot package these modules.

2. It is very simple to complete the above requirements because Webpack has built-in support for Electron. You only need to add a line of code to the Webpack configuration file, as follows:

target: 'electron-renderer',

This configuration was once in 2-7 Other configuration items-Target Mentioned in, it means to let Webpack build the JavaScript code for the Electron rendering process, which is the web page code required by these two windows.

After the above modifications are completed, re-execute the Webpack build. The codes required for the corresponding web pages will be output to the dist directory in the project root directory.

In order to run as an Electron application, you need to install new dependencies:

# 安装 Electron 执行环境到项目中
npm i -D electron

After successful installation, execute electron in the project directory. You will be successful See the launched desktop application, the effect is as shown below:

Related recommendations:

Electron builds React, Webpack desktop application tutorial

Electron uses html js css to develop desktop applications under Windows_html/css_WEB-ITnose

Write desktop applications with electron_html/css_WEB-ITnose

The above is the detailed content of Webpack practical construction Electron application examples detailed explanation. For more information, please follow other related articles on the PHP Chinese website!