Node.js 實現(xiàn)遠程桌面監(jiān)控的方法步驟

更新時間：2019年07月02日 09:02:20 作者：凌霄光

這篇文章主要介紹了Node.js 實現(xiàn)遠程桌面監(jiān)控的方法步驟，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧

描述

最近使用node實現(xiàn)了一個遠程桌面監(jiān)控的應(yīng)用，分為服務(wù)端和客戶端，客戶端可以實時監(jiān)控服務(wù)端的桌面，并且可以通過鼠標和鍵盤來控制服務(wù)端的桌面。

這里因為我是用的同一臺電腦，所以監(jiān)控畫面是這樣的，當然使用兩臺電腦一個跑客戶端，一個跑服務(wù)端才有意義。

原理

其實這個應(yīng)用的功能主要分為兩部分，一是實現(xiàn)監(jiān)控，即在客戶端可以看到服務(wù)端的桌面，這部分功能是通過定時截圖來實現(xiàn)的，比如服務(wù)端一秒截幾次圖，然后通過socketio發(fā)送到客戶端，客戶端通過改變img的src來實現(xiàn)一幀幀的顯示最新的圖片，這樣就能看到動態(tài)的桌面了。監(jiān)控就是這樣實現(xiàn)的。

另一個功能是控制，即客戶端對監(jiān)控畫面的操作，包括鼠標和鍵盤的操作都可以在服務(wù)端的桌面真正的生效，這部分功能的實現(xiàn)是在electron的應(yīng)用中監(jiān)聽了所有的鼠標和鍵盤事件，比如keydown、keyup、keypress，mousedown、mouseup、mousemove、click等，然后通過socketio把事件傳遞到服務(wù)端，服務(wù)端通過 robot-js來執(zhí)行不同的事件，這樣就能使得客戶端的事件在服務(wù)端觸發(fā)了。

實現(xiàn)

原理講完，我們來具體實現(xiàn)一下（源碼鏈接在這）。

實現(xiàn)socket通信

首先，服務(wù)端和客戶端分別引入socket.io和socket.io-client, 分別初始化

服務(wù)端：

const app = new Koa();
const server = http.createServer(app.callback());
createSocketIO(server);

app.use((ctx): void => {
  ctx.body = 'please connect use socket';
});

server.listen(port, (): void => {
  console.log('server started at http://localhost:' + port);
});

//createSocketIO
const io = socketIO(server, {
    pingInterval: 10000,
    pingTimeout: 5000,
    cookie: false
  });

io.on('connect', (socket): void => {
  socket.emit('msg', 'connected');
}

客戶端：

var socket = this.socket = io('http://' + this.ip + ':3000')
socket.on('msg', (msg) => {
 console.log(msg)
})
socket.on('error', (err) => {
 alert('出錯了' + err)
})

這樣，服務(wù)端和客戶端就通過socketio建立了鏈接。

實現(xiàn)桌面監(jiān)控

之后我們首先要在服務(wù)端來截圖，使用screenshot-desktop這個包

const screenshot = require('screenshot-desktop')

const SCREENSHOT_INTERVAL = 500;

export const createScreenshot = (): Promise<[string, Buffer]> => {
  return screenshot({format: 'png'}).then((img): [string, Buffer] => {
    return [ img.toString('base64'), img];
  }).catch((err): {} => {
    console.log('截圖失敗', err);
    return err;
  })
}

export const startScreenshotTimer = (callback): {} => {
  return setInterval((): void => {
    createScreenshot().then(([imgStr, img]): void => {
      callback(['data:image/png;base64,' + imgStr, img]);
    })
  }, SCREENSHOT_INTERVAL)
}

然后通過socketio的emit來傳到客戶端：

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

客戶端收到圖片后，設(shè)置到img的src上（這里是base64的圖片url）:

 <img 
  class="screenshot" 
  :src="screenshot"
/>

data () {
 return {
  screenshot: ''
 }
}

socket.on('screenshot', (data) => {
 this.screenshot = data
})

其實這樣就已經(jīng)實現(xiàn)了桌面監(jiān)控了，有興趣的同學可以照著這個思路實現(xiàn)看看，并不是很麻煩。

當然這樣的方案是有問題的，因為我們需要知道服務(wù)端桌面尺寸的大小，然后根據(jù)這個來調(diào)整客戶端顯示的圖片尺寸。

實現(xiàn)這個細節(jié)是使用的get-pixels這個庫，可以讀取本地圖片文件的寬度高度等信息，所以我先把圖片寫入本地，然后又讀取出來，這樣獲取到的屏幕尺寸。

interface ScreenSize {
  width: number;
  height: number;
}

function getScreenSize(img): Promise<ScreenSize> {
  const imgPath = path.resolve(process.cwd(), './tmp.png');
  fs.writeFileSync(imgPath, img);
  return new Promise((resolve): void => {
    getPixels(imgPath, function(err, pixels): void {
      if(err) {
        console.log("Bad image path")
        return
      }
      resolve({
        width: pixels.shape[0],
        height: pixels.shape[1]
      });
    });
  })
}

然后通過socektio傳遞給客戶端

getScreenSize(img).then(({ width, height}) => {
  io.sockets.emit('screensize', {
    width,
    height
  })
});

客戶端收到之后調(diào)整圖片大小就可以了

<img 
  class="screenshot" 
  :src="screenshot"
  :style="screenshotStyle"
/>

data () {
 return {
  screenshot: '',
  screenshotStyle: '',
 }
}

socket.on('screensize', (screensize) => {
 this.screenshotStyle = {'width': screensize.width + 'px', 'height': screensize.height + 'px'}
})

至此已經(jīng)實現(xiàn)了桌面監(jiān)控，并且圖片尺寸和服務(wù)端屏幕的尺寸是一致的。

這里還有一個細節(jié)，就是獲取到的圖片大小是物理像素，而客戶端設(shè)置的px是設(shè)備無關(guān)像素，也就是要除以dpr才是px的值。這里需要獲取dpr，因為目前只是在mac下用，所以直接除以2了。

實現(xiàn)遠程控制

代碼寫到這里，客戶端的electron應(yīng)用中已經(jīng)可以實時顯示服務(wù)端的桌面了。（當然像輸入ip的彈框，以及electron-vue和typescript等和主要邏輯無關(guān)的細節(jié)就不展開了。）

接下來我們要實現(xiàn)遠程控制，也就是監(jiān)聽事件，傳遞事件，執(zhí)行事件這幾部分。

首先我們定義一下傳遞的事件的格式：

interface MouseEvent {
  type: string;
  buttonType: string;
  x: number;
  y: number;
}

interface KeyboardEvent {
  type: string;
  keyCode: number;
  keyName: string;
}

鼠標事件MouseEvent，type為鼠標事件的類型，具體的值包括mousedown、mouseup、mousemove、click、dblclick，buttonType指的是鼠標的左鍵還是右鍵，值為 left 或 right，x和y是具體的坐標。

鍵盤事件KeyboardEvent，type為鍵盤事件的類型，具體的值包括keydown、keyup、keypress，keyCode為鍵盤碼，keyName為鍵的名字。

接下來我們要在客戶端監(jiān)聽事件：

<img 
  class="screenshot" 
  :src="screenshot"
  :style="screenshotStyle"
  @mousedown="handleMouseEvent"
  @mousemove="handleMouseEvent" 
  @mouseup="handleMouseEvent"
  @click="handleMouseEvent"
  @dblclick="handleMouseEvent"  
/>

window.onkeypress = window.onkeyup = window.onkeydown = this.handleKeyboardEvent

通過socekt把事件傳遞到服務(wù)端

 handleKeyboardEvent (e) {
  this.socket && this.socket.emit('userevent', {
   type: 'keyboard',
   event: {
    type: e.type,
    keyName: e.key,
    keyCode: e.keyCode
   }
  })
 },
 handleMouseEvent (e) {
  this.socket && this.socket.emit('userevent', {
   type: 'mouse',
   event: {
    type: e.type,
    buttonType: e.buttons === 2 ? 'right' : 'left',
    x: e.clientX,
    y: e.clientY
   }
  })
 },

然后在服務(wù)端把事件取出來執(zhí)行，執(zhí)行事件使用的是robot-js：

const { Mouse, Point, Keyboard } = require('robot-js');

interface MouseEvent {
  type: string;
  buttonType: string;
  x: number;
  y: number;
}

interface KeyboardEvent {
  type: string;
  keyCode: number;
  keyName: string;
}

export default class EventExecuter {
  public mouse;
  public keyboard;
  public constructor(){
    this.mouse = new Mouse();
    this.keyboard = new Keyboard();
  }

  public executeKeyboardEvent(event: KeyboardEvent): void {
    switch(event.type) {
      case 'keydown':
        this.keyboard.press(event.keyCode);
        break;
      case 'keyup':
        this.keyboard.release(event.keyCode);
        break;
      case 'keypress':
        this.keyboard.click(event.keyCode);
        break;
      default: break;
    }
  }

  public executeMouseEvent(event): void {
    Mouse.setPos(new Point(event.x, event.y));
    const button = event.buttonType === 'left' ? 0 : 2
    switch(event.type) {
      case 'mousedown':
        this.mouse.press(button);
        break;
      case 'mousemove':
        break;
      case 'mouseup': 
        this.mouse.release(button);
        break;
      case 'click': 
        this.mouse.click(button);
        break;
      case 'dblclick': 
        this.mouse.click(button);
        this.mouse.click(button);
        break;
      default: break;
    }
  }

  public exectue(eventInfo): void {
    console.log(eventInfo);
    switch (eventInfo.type) {
      case 'keyboard':
        this.executeKeyboardEvent(eventInfo.event);
        break;
      case 'mouse':
        this.executeMouseEvent(eventInfo.event);
        break;
      default: break;
    }
  }
}

至此，桌面監(jiān)控和遠程控制的客戶端還有服務(wù)端的部分，以及兩端的通信都已經(jīng)實現(xiàn)了。思路其實并不麻煩，但細節(jié)還是很多的。有興趣的同學可以把代碼下下來跑跑試試，或者按著這個思路自己實現(xiàn)一遍，還是挺好玩的。

源碼鏈接

remote-monitor-server

remote-monitor-client

以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: