经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » JS/JS库/框架 » Node.js » 查看文章
Node.js 实现远程桌面监控的方法步骤
来源:jb51  时间:2019/7/2 12:04:41  对本文有异议

描述

最近使用node实现了一个远程桌面监控的应用,分为服务端和客户端,客户端可以实时监控服务端的桌面,并且可以通过鼠标和键盘来控制服务端的桌面。

这里因为我是用的同一台电脑,所以监控画面是这样的,当然使用两台电脑一个跑客户端,一个跑服务端才有意义。

原理

其实这个应用的功能主要分为两部分,一是实现监控,即在客户端可以看到服务端的桌面,这部分功能是通过定时截图来实现的,比如服务端一秒截几次图,然后通过socketio发送到客户端,客户端通过改变img的src来实现一帧帧的显示最新的图片,这样就能看到动态的桌面了。监控就是这样实现的。

另一个功能是控制,即客户端对监控画面的操作,包括鼠标和键盘的操作都可以在服务端的桌面真正的生效,这部分功能的实现是在electron的应用中监听了所有的鼠标和键盘事件,比如keydown、keyup、keypress,mousedown、mouseup、mousemove、click等,然后通过socketio把事件传递到服务端,服务端通过 robot-js来执行不同的事件,这样就能使得客户端的事件在服务端触发了。

实现

原理讲完,我们来具体实现一下(源码链接在这)。

实现socket通信

首先,服务端和客户端分别引入socket.io和socket.io-client, 分别初始化

服务端:

  1. const app = new Koa();
  2. const server = http.createServer(app.callback());
  3. createSocketIO(server);
  4.  
  5. app.use((ctx): void => {
  6. ctx.body = 'please connect use socket';
  7. });
  8.  
  9. server.listen(port, (): void => {
  10. console.log('server started at http://localhost:' + port);
  11. });
  12.  
  13. //createSocketIO
  14. const io = socketIO(server, {
  15. pingInterval: 10000,
  16. pingTimeout: 5000,
  17. cookie: false
  18. });
  19.  
  20. io.on('connect', (socket): void => {
  21. socket.emit('msg', 'connected');
  22. }
  23.  

客户端:

  1. var socket = this.socket = io('http://' + this.ip + ':3000')
  2. socket.on('msg', (msg) => {
  3. console.log(msg)
  4. })
  5. socket.on('error', (err) => {
  6. alert('出错了' + err)
  7. })
  8.  

这样,服务端和客户端就通过socketio建立了链接。

实现桌面监控

之后我们首先要在服务端来截图,使用screenshot-desktop这个包

  1. const screenshot = require('screenshot-desktop')
  2.  
  3. const SCREENSHOT_INTERVAL = 500;
  4.  
  5. export const createScreenshot = (): Promise<[string, Buffer]> => {
  6. return screenshot({format: 'png'}).then((img): [string, Buffer] => {
  7. return [ img.toString('base64'), img];
  8. }).catch((err): {} => {
  9. console.log('截图失败', err);
  10. return err;
  11. })
  12. }
  13.  
  14. export const startScreenshotTimer = (callback): {} => {
  15. return setInterval((): void => {
  16. createScreenshot().then(([imgStr, img]): void => {
  17. callback(['data:image/png;base64,' + imgStr, img]);
  18. })
  19. }, SCREENSHOT_INTERVAL)
  20. }

然后通过socketio的emit来传到客户端:

  1. startScreenshotTimer(([imgStr, img]): void => {
  2. io.sockets.emit('screenshot', imgStr);
  3. });
  4.  

客户端收到图片后,设置到img的src上(这里是base64的图片url):

  1. <img
  2. class="screenshot"
  3. :src="screenshot"
  4. />
  5.  
  1. data () {
  2. return {
  3. screenshot: ''
  4. }
  5. }
  1. socket.on('screenshot', (data) => {
  2. this.screenshot = data
  3. })
  4.  

其实这样就已经实现了桌面监控了,有兴趣的同学可以照着这个思路实现看看,并不是很麻烦。

当然这样的方案是有问题的,因为我们需要知道服务端桌面尺寸的大小,然后根据这个来调整客户端显示的图片尺寸。

实现这个细节是使用的get-pixels这个库,可以读取本地图片文件的宽度高度等信息,所以我先把图片写入本地,然后又读取出来,这样获取到的屏幕尺寸。

  1. interface ScreenSize {
  2. width: number;
  3. height: number;
  4. }
  5.  
  6. function getScreenSize(img): Promise<ScreenSize> {
  7. const imgPath = path.resolve(process.cwd(), './tmp.png');
  8. fs.writeFileSync(imgPath, img);
  9. return new Promise((resolve): void => {
  10. getPixels(imgPath, function(err, pixels): void {
  11. if(err) {
  12. console.log("Bad image path")
  13. return
  14. }
  15. resolve({
  16. width: pixels.shape[0],
  17. height: pixels.shape[1]
  18. });
  19. });
  20. })
  21. }

然后通过socektio传递给客户端

  1. getScreenSize(img).then(({ width, height}) => {
  2. io.sockets.emit('screensize', {
  3. width,
  4. height
  5. })
  6. });
  7.  

客户端收到之后调整图片大小就可以了

  1. <img
  2. class="screenshot"
  3. :src="screenshot"
  4. :style="screenshotStyle"
  5. />
  6.  
  1. data () {
  2. return {
  3. screenshot: '',
  4. screenshotStyle: '',
  5. }
  6. }
  1. socket.on('screensize', (screensize) => {
  2. this.screenshotStyle = {'width': screensize.width + 'px', 'height': screensize.height + 'px'}
  3. })
  4.  

至此已经实现了桌面监控,并且图片尺寸和服务端屏幕的尺寸是一致的。

这里还有一个细节,就是获取到的图片大小是物理像素,而客户端设置的px是设备无关像素,也就是要除以dpr才是px的值。这里需要获取dpr,因为目前只是在mac下用,所以直接除以2了。

实现远程控制

代码写到这里,客户端的electron应用中已经可以实时显示服务端的桌面了。(当然像输入ip的弹框,以及electron-vue和typescript等和主要逻辑无关的细节就不展开了。)

接下来我们要实现远程控制,也就是监听事件,传递事件,执行事件这几部分。

首先我们定义一下传递的事件的格式:

  1. interface MouseEvent {
  2. type: string;
  3. buttonType: string;
  4. x: number;
  5. y: number;
  6. }
  7.  
  8. interface KeyboardEvent {
  9. type: string;
  10. keyCode: number;
  11. keyName: string;
  12. }
  13.  

鼠标事件MouseEvent,type为鼠标事件的类型,具体的值包括mousedown、mouseup、mousemove、click、dblclick,buttonType指的是鼠标的左键还是右键,值为 left 或 right,x和y是具体的坐标。

键盘事件KeyboardEvent,type为键盘事件的类型,具体的值包括keydown、keyup、keypress,keyCode为键盘码,keyName为键的名字。

接下来我们要在客户端监听事件:

  1. <img
  2. class="screenshot"
  3. :src="screenshot"
  4. :style="screenshotStyle"
  5. @mousedown="handleMouseEvent"
  6. @mousemove="handleMouseEvent"
  7. @mouseup="handleMouseEvent"
  8. @click="handleMouseEvent"
  9. @dblclick="handleMouseEvent"
  10. />
  11.  
  1. window.onkeypress = window.onkeyup = window.onkeydown = this.handleKeyboardEvent
  2.  

通过socekt把事件传递到服务端

  1. handleKeyboardEvent (e) {
  2. this.socket && this.socket.emit('userevent', {
  3. type: 'keyboard',
  4. event: {
  5. type: e.type,
  6. keyName: e.key,
  7. keyCode: e.keyCode
  8. }
  9. })
  10. },
  11. handleMouseEvent (e) {
  12. this.socket && this.socket.emit('userevent', {
  13. type: 'mouse',
  14. event: {
  15. type: e.type,
  16. buttonType: e.buttons === 2 ? 'right' : 'left',
  17. x: e.clientX,
  18. y: e.clientY
  19. }
  20. })
  21. },
  22.  

然后在服务端把事件取出来执行,执行事件使用的是robot-js

  1. const { Mouse, Point, Keyboard } = require('robot-js');
  2.  
  3. interface MouseEvent {
  4. type: string;
  5. buttonType: string;
  6. x: number;
  7. y: number;
  8. }
  9.  
  10. interface KeyboardEvent {
  11. type: string;
  12. keyCode: number;
  13. keyName: string;
  14. }
  15.  
  16. export default class EventExecuter {
  17. public mouse;
  18. public keyboard;
  19. public constructor(){
  20. this.mouse = new Mouse();
  21. this.keyboard = new Keyboard();
  22. }
  23.  
  24. public executeKeyboardEvent(event: KeyboardEvent): void {
  25. switch(event.type) {
  26. case 'keydown':
  27. this.keyboard.press(event.keyCode);
  28. break;
  29. case 'keyup':
  30. this.keyboard.release(event.keyCode);
  31. break;
  32. case 'keypress':
  33. this.keyboard.click(event.keyCode);
  34. break;
  35. default: break;
  36. }
  37. }
  38.  
  39. public executeMouseEvent(event): void {
  40. Mouse.setPos(new Point(event.x, event.y));
  41. const button = event.buttonType === 'left' ? 0 : 2
  42. switch(event.type) {
  43. case 'mousedown':
  44. this.mouse.press(button);
  45. break;
  46. case 'mousemove':
  47. break;
  48. case 'mouseup':
  49. this.mouse.release(button);
  50. break;
  51. case 'click':
  52. this.mouse.click(button);
  53. break;
  54. case 'dblclick':
  55. this.mouse.click(button);
  56. this.mouse.click(button);
  57. break;
  58. default: break;
  59. }
  60. }
  61.  
  62. public exectue(eventInfo): void {
  63. console.log(eventInfo);
  64. switch (eventInfo.type) {
  65. case 'keyboard':
  66. this.executeKeyboardEvent(eventInfo.event);
  67. break;
  68. case 'mouse':
  69. this.executeMouseEvent(eventInfo.event);
  70. break;
  71. default: break;
  72. }
  73. }
  74. }
  75.  

至此,桌面监控和远程控制的客户端还有服务端的部分,以及两端的通信都已经实现了。思路其实并不麻烦,但细节还是很多的。有兴趣的同学可以把代码下下来跑跑试试,或者按着这个思路自己实现一遍,还是挺好玩的。

源码链接

remote-monitor-server

remote-monitor-client

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持w3xue。

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号