Node.js 實現遠程桌面監控

時間 2021-04-04

標籤 vue node git github typescript cookie app electron socket 欄目 Node.js 简体版

原文原文鏈接

描述

最近使用node實現了一個遠程桌面監控的應用，分爲服務端和客戶端，客戶端能夠實時監控服務端的桌面，而且能夠經過鼠標和鍵盤來控制服務端的桌面。vue

這裏由於我是用的同一臺電腦，因此監控畫面是這樣的，固然使用兩臺電腦一個跑客戶端，一個跑服務端纔有意義。node

原理

其實這個應用的功能主要分爲兩部分，一是實現監控，即在客戶端能夠看到服務端的桌面，這部分功能是經過定時截圖來實現的，好比服務端一秒截幾回圖，而後經過socketio發送到客戶端，客戶端經過改變img的src來實現一幀幀的顯示最新的圖片，這樣就能看到動態的桌面了。監控就是這樣實現的。git

另外一個功能是控制，即客戶端對監控畫面的操做，包括鼠標和鍵盤的操做均可以在服務端的桌面真正的生效，這部分功能的實現是在electron的應用中監聽了全部的鼠標和鍵盤事件，好比keydown、keyup、keypress，mousedown、mouseup、mousemove、click等，而後經過socketio把事件傳遞到服務端，服務端經過 robot-js來執行不一樣的事件，這樣就能使得客戶端的事件在服務端觸發了。github

實現

原理講完，咱們來具體實現一下（源碼連接在這）。typescript

實現socket通訊

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

服務端：app

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');
}

客戶端：electron

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

這樣，服務端和客戶端就經過socketio創建了連接。socket

實現桌面監控

以後咱們首先要在服務端來截圖，使用screenshot-desktop這個包ui

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);
});

客戶端收到圖片後，設置到img的src上（這裏是base64的圖片url）:

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

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

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

其實這樣就已經實現了桌面監控了，有興趣的同窗能夠照着這個思路實現看看，並非很麻煩。

固然這樣的方案是有問題的，由於咱們須要知道服務端桌面尺寸的大小，而後根據這個來調整客戶端顯示的圖片尺寸。

實現這個細節是使用的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
    })
});

客戶端收到以後調整圖片大小就能夠了

<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'}
})

至此已經實現了桌面監控，而且圖片尺寸和服務端屏幕的尺寸是一致的。

這裏還有一個細節，就是獲取到的圖片大小是物理像素，而客戶端設置的px是設備無關像素，也就是要除以dpr纔是px的值。這裏須要獲取dpr，由於目前只是在mac下用，因此直接除以2了。

實現遠程控制

代碼寫到這裏，客戶端的electron應用中已經能夠實時顯示服務端的桌面了。（固然像輸入ip的彈框，以及electron-vue和typescript等和主要邏輯無關的細節就不展開了。）

接下來咱們要實現遠程控制，也就是監聽事件，傳遞事件，執行事件這幾部分。

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

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爲鍵的名字。

接下來咱們要在客戶端監聽事件：

<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把事件傳遞到服務端

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.offsetX,
        y: e.offsetY
      }
    })
  },

而後在服務端把事件取出來執行，執行事件使用的是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;
        }
    }
}

至此，桌面監控和遠程控制的客戶端還有服務端的部分，以及兩端的通訊都已經實現了。思路其實並不麻煩，但細節仍是不少的。有興趣的同窗能夠把代碼下下來跑跑試試，或者按着這個思路本身實現一遍，仍是挺好玩的。