用robotgo库来实现一个自动化过程。
自动打开一个记事本，输入当前日期并且保存记事本，最后关闭记事本。
同时全局监听键盘事件，当按下组合键“ctrl+shift+q”后退出程序。
自动化记事本
package main
import (
"fmt"
"time"
"github.com/go-vgo/robotgo"
hook "github.com/robotn/gohook"
)
func main() {
robotgo.EventHook(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
fmt.Println("keydown exit")
robotgo.EventEnd()
})
go func() {
start()
}()
fmt.Println("waiting, press \"ctrl+shift+q\" Exit")
s := robotgo.EventStart()
<-robotgo.EventProcess(s)
fmt.Println("exit")
}
func start() {
// 鼠标移动到开始菜单并且单击鼠标左键打开菜单（我的开始菜单在右上角）
robotgo.MoveClick(1401, 27, "left", false)
// 输入文字搜索notepad
robotgo.TypeStr("notepad", float64(100))
// 回车打开记事本
robotgo.KeyTap("enter")
time.Sleep(1 * time.Second)
// 获取当前时间作为文本内容，写入到记事本中
str := "current time:" + time.Now().Format("2006-01-02 15:04:05")
robotgo.TypeStr(str, float64(100))
// 按下Ctrl+s组合键保存
robotgo.KeyTap("s", "lctrl")
time.Sleep(1 * time.Second)
// 输入要保存的记事本名字
name := fmt.Sprintf("robotgo%s.txt", time.Now().Format("20060102150405"))
robotgo.TypeStr(name, float64(100))
// 回车确认保存
robotgo.KeyTap("enter")
time.Sleep(1 * time.Second)
// 按下Alt+f键打开记事本菜单
robotgo.KeyTap("f", "alt")
time.Sleep(1 * time.Second)
// 按下菜单中的x键退出记事本
robotgo.KeyTap("X")
}
录入回放
demo.exe -mode write 录入鼠标、键盘的动作写入到本地文件track.dat中
demo.exe -mode read 读取录入的动作，自动化执行， -count指定执行次数，默认是1
package main
import (
"bufio"
"encoding/json"
"flag"
"fmt"
"io"
"os"
"strings"
"time"
"github.com/go-vgo/robotgo"
hook "github.com/robotn/gohook"
)
func main() {
var mode string
var readCount int
flag.StringVar(&mode, "mode", "", "mode, read or write")
flag.IntVar(&readCount, "count", 1, "read count, default 1")
flag.Parse()
robotgo.EventHook(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
fmt.Println("keydown exit")
robotgo.EventEnd()
})
if mode == "read" {
read(readCount)
} else if mode == "write" {
write()
} else {
panic("mode is unkown")
}
}
func Mask2str(mask uint16) string {
data := map[uint16]string{
0: "",
2: "ctrl",
32: "ctrl",
8: "alt",
128: "alt",
1: "shift",
16: "shift",
}
str, ok := data[mask]
if !ok {
fmt.Println("Mask2str unkown:", mask)
}
return str
}
func Button2str(button uint16) string {
data := map[uint16]string{
1: "left",
2: "right",
3: "center",
}
str, ok := data[button]
if !ok {
fmt.Println("Button2str unkown:", button)
}
return str
}
type Track struct {
Tm time.Time
File *os.File
}
type Item struct {
When uint8
X int16
Y int16
Button string
Char string
Mask string
Sleep time.Duration
}
func NewTrackWrite(filename string, isTrunc bool) *Track {
track := &Track{}
track.Tm = time.Now()
flag := os.O_APPEND | os.O_WRONLY | os.O_CREATE
if isTrunc {
flag |= os.O_TRUNC
}
f, err := os.OpenFile(filename, flag, 0600)
if err != nil {
panic(err)
}
track.File = f
return track
}
func NewTrackRead(filename string) *Track {
track := &Track{}
f, err := os.OpenFile(filename, os.O_RDONLY, 0600)
if err != nil {
panic(err)
}
track.File = f
return track
}
func (track *Track) Close() {
track.File.Close()
}
func (track *Track) WriteItem(item Item) {
b, err := json.Marshal(item)
if err != nil {
fmt.Println(err)
} else {
track.File.WriteString(string(b) + "\n")
}
}
func (track *Track) ReadItem(handler func(item Item)) error {
buf := bufio.NewReader(track.File)
for {
line, err := buf.ReadString('\n')
line = strings.TrimSpace(line)
item := Item{}
if e := json.Unmarshal([]byte(line), &item); e == nil {
handler(item)
}
if err != nil {
if err == io.EOF {
return nil
}
return err
}
}
}
func (track *Track) AddMouseMove(x, y int16) {
item := Item{}
item.When = hook.MouseMove
item.X = x
item.Y = y
item.Sleep = time.Since(track.Tm)
track.Tm = time.Now()
track.WriteItem(item)
}
func (track *Track) AddMouseDown(x, y int16, button string) {
item := Item{}
item.When = hook.MouseDown
item.X = x
item.Y = y
item.Button = button
item.Sleep = time.Since(track.Tm)
track.Tm = time.Now()
track.WriteItem(item)
}
func (track *Track) AddKeyDown(char, mask string) {
fmt.Println("add key down:", char, mask)
item := Item{}
item.When = hook.KeyDown
item.Char = char
item.Mask = mask
item.Sleep = time.Since(track.Tm)
track.Tm = time.Now()
track.WriteItem(item)
}
func write() {
track := NewTrackWrite("./track.dat", true)
defer track.Close()
robotgo.EventHook(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
fmt.Println("keydown exit")
robotgo.EventEnd()
})
robotgo.EventHook(hook.KeyDown, []string{}, func(e hook.Event) {
track.AddKeyDown(fmt.Sprintf("%c", e.Keychar), Mask2str(e.Mask))
})
robotgo.EventHook(hook.MouseMove, []string{}, func(e hook.Event) {
track.AddMouseMove(e.X, e.Y)
})
robotgo.EventHook(hook.MouseDown, []string{}, func(e hook.Event) {
track.AddMouseDown(e.X, e.Y, Button2str(e.Button))
})
s := robotgo.EventStart()
fmt.Println("running, press \"ctrl+shift+q\" Exit")
<-robotgo.EventProcess(s)
}
func read(count int) {
track := NewTrackRead("./track.dat")
defer track.Close()
items := make(chan Item, 10)
go func() {
for i := 0; i < count; i++ {
track.ReadItem(func(item Item) {
time.Sleep(item.Sleep)
items <- item
})
}
close(items)
robotgo.EventEnd()
}()
go func() {
for item := range items {
if item.When == hook.MouseMove {
robotgo.MoveMouse(int(item.X), int(item.Y))
} else if item.When == hook.MouseDown {
robotgo.MoveClick(int(item.X), int(item.Y), item.Button, false)
} else if item.When == hook.KeyDown {
if len(item.Mask) == 0 {
robotgo.KeyTap(item.Char)
} else {
robotgo.KeyTap(item.Char, item.Mask)
}
}
}
}()
robotgo.EventHook(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
fmt.Println("keydown exit")
robotgo.EventEnd()
})
s := robotgo.EventStart()
fmt.Println("running, press \"ctrl+shift+q\" Exit")
<-robotgo.EventProcess(s)
}
