Robotgo

Golang 桌面自动化、自动化测试及人工智能计算机应用。
控制鼠标、键盘，读取屏幕内容，处理窗口句柄、图像和位图，以及全局事件监听。

RobotGo 支持 macOS、Windows 和 Linux (X11)；同时支持 arm64 和 x86-amd64 架构。

RobotGo-Pro 提供 JavaScript、Python、Lua 等版本的支持，技术协助、新功能以及最新版的 RobotGo（例如 Wayland 支持，“目前无开源版本”）。

目录

• 文档
• 绑定
• 要求
• 安装
• 更新
• 示例
• 类型转换与按键
• 交叉编译
• 作者
• 计划
• 许可证

文档

• GoDoc
  
• API 文档（已弃用，未更新）

绑定：

ADB，封装了 Android ADB API。

要求：

现在，请确保在安装 RobotGo 之前，Golang 和 GCC 已正确安装。

全部：

Golang

GCC

对于 macOS：

brew install go

Xcode 命令行工具；
并且需要在隐私设置中添加“屏幕录制”和“辅助功能”权限：
系统设置 > 隐私与安全性 > 辅助功能、屏幕与系统音频录制。

xcode-select --install

对于 Windows：

winget install Golang.go

llvm-mingw

winget install MartinStorsjo.LLVM-MinGW.UCRT

或者 Mingw-w64

winget install BrechtSanders.WinLibs.POSIX.UCRT

或者下载 Mingw-w64 及其他 GCC 编译器，然后将类似 C:\mingw64\bin 的路径添加到系统的环境变量 Path 中。
设置环境变量以便从命令行运行 GCC。

或者使用其他 GCC（除了 Mingw-w64 外，使用 bitmap 时需自行编译 “libpng”）。

对于其他所有系统：

GCC

X11 并配备 XTest 扩展（Xtst 库）

“剪贴板”：xsel、xclip

“位图”：libpng（仅用于 bitmap）

“事件监听”：xcb、xkb、libxkbcommon（仅用于 hook）

Ubuntu：

# sudo apt install golang
sudo snap install go  --classic

# gcc
sudo apt install gcc libc6-dev

# x11
sudo apt install libx11-dev xorg-dev libxtst-dev

# 剪贴板
sudo apt install xsel xclip

# 位图
sudo apt install libpng++-dev

# GoHook
sudo apt install xcb libxcb-xkb-dev x11-xkb-utils libx11-xcb-dev libxkbcommon-x11-dev libxkbcommon-dev

Fedora：

# x11
sudo dnf install libXtst-devel

# 剪贴板
sudo dnf install xsel xclip

# 位图
sudo dnf install libpng-devel

# GoHook
sudo dnf install libxkbcommon-devel libxkbcommon-x11-devel xorg-x11-xkb-utils-devel

安装：

如果支持 Go 模块（Go 1.11 及以上版本），只需导入：

import "github.com/go-vgo/robotgo"

否则，要安装 robotgo 包，运行以下命令：

go get github.com/go-vgo/robotgo

png.h：没有这样的文件或目录？请参阅 issues/47。

更新：

go get -u github.com/go-vgo/robotgo

注意 go1.10.x C 文件编译缓存问题，golang #24355。
go mod vendor 问题，golang #26366。

示例：

鼠标

package main

import (
  "fmt"
  "github.com/go-vgo/robotgo"
)

func main() {
  robotgo.MouseSleep = 300

  robotgo.Move(100, 100)
  fmt.Println(robotgo.Location())
  robotgo.Move(100, -200) // 支持多屏
  robotgo.MoveSmooth(120, -150)
  fmt.Println(robotgo.Location())

  robotgo.ScrollDir(10, "up")
  robotgo.ScrollDir(20, "right")

  robotgo.Scroll(0, -10)
  robotgo.Scroll(100, 0)

  robotgo.MilliSleep(100)
  robotgo.ScrollSmooth(-10, 6)
  // robotgo.ScrollRelative(10, -100)

  robotgo.Move(10, 20)
  robotgo.MoveRelative(0, -10)
  robotgo.DragSmooth(10, 10)

  robotgo.Click("wheelRight")
  robotgo.Click("left", true)
  robotgo.MoveSmooth(100, 200, 1.0, 10.0)

  robotgo.Toggle("left")
  robotgo.Toggle("left", "up")
}

键盘

package main

import (
  "fmt"

  "github.com/go-vgo/robotgo"
)

func main() {
  robotgo.Type("Hello World")
  robotgo.Type("だんしゃり", 0, 1)
  // robotgo.Type("テストする")

  robotgo.Type("Hi, Seattle space needle, Golden gate bridge, One world trade center.")
  robotgo.Type("Hi galaxy, hi stars, hi MT.Rainier, hi sea. こんにちは世界.")
  robotgo.Sleep(1)

  // ustr := uint32(robotgo.CharCodeAt("Test", 0))
  // robotgo.UnicodeType(ustr)

  robotgo.KeySleep = 100
  robotgo.KeyTap("enter")
  // robotgo.Type("en")
  robotgo.KeyTap("i", "alt", "cmd")

  arr := []string{"alt", "cmd"}
  robotgo.KeyTap("i", arr)

  robotgo.MilliSleep(100)
  robotgo.KeyToggle("a")
  robotgo.KeyToggle("a", "up")

  robotgo.WriteAll("Test")
  text, err := robotgo.ReadAll()
  if err == nil {
    fmt.Println(text)
  }
}

屏幕

package main

import (
  "fmt"
  "strconv"

  "github.com/go-vgo/robotgo"
  "github.com/vcaesar/imgo"
)

func main() {
  x, y := robotgo.Location()
  fmt.Println("pos: ", x, y)

  color := robotgo.GetPixelColor(100, 200)
  fmt.Println("color---- ", color)

  sx, sy := robotgo.GetScreenSize()
  fmt.Println("获取屏幕尺寸: ", sx, sy)

  bit := robotgo.CaptureScreen(10, 10, 30, 30)
  defer robotgo.FreeBitmap(bit)

  img := robotgo.ToImage(bit)
  imgo.Save("test.png", img)

num := robotgo.DisplaysNum()
  for i := 0; i < num; i++ {
    robotgo.DisplayID = i
    img1, _ := robotgo.CaptureImg()
    path1 := "save_" + strconv.Itoa(i)
    robotgo.Save(img1, path1+".png")
    robotgo.SaveJpeg(img1, path1+".jpeg", 50)

    img2, _ := robotgo.CaptureImg(10, 10, 20, 20)
    robotgo.Save(img2, "test_"+strconv.Itoa(i)+".png")

    x, y, w, h := robotgo.GetDisplayBounds(i)
    img3, err := robotgo.CaptureImg(x, y, w, h)
    fmt.Println("Capture error: ", err)
    robotgo.Save(img3, path1+"_1.png")
  }
}

Bitmap

package main

import (
  "fmt"

  "github.com/go-vgo/robotgo"
  "github.com/vcaesar/bitmap"
)

func main() {
  bit := robotgo.CaptureScreen(10, 20, 30, 40)
  // 使用 `defer robotgo.FreeBitmap(bit)` 来释放位图
  defer robotgo.FreeBitmap(bit)

  fmt.Println("bitmap...", bit)
  img := robotgo.ToImage(bit)
  // robotgo.SavePng(img, "test_1.png")
  robotgo.Save(img, "test_1.png")

  bit2 := robotgo.ToCBitmap(robotgo.ImgToBitmap(img))
  fx, fy := bitmap.Find(bit2)
  fmt.Println("FindBitmap------ ", fx, fy)
  robotgo.Move(fx, fy)

  arr := bitmap.FindAll(bit2)
  fmt.Println("Find all bitmap: ", arr)

  fx, fy = bitmap.Find(bit)
  fmt.Println("FindBitmap------ ", fx, fy)

  bitmap.Save(bit, "test.png")
}

OpenCV

package main

import (
  "fmt"
  "math/rand"

  "github.com/go-vgo/robotgo"
  "github.com/vcaesar/gcv"
  "github.com/vcaesar/bitmap"
)

func main() {
  opencv()
}

func opencv() {
  name := "test.png"
  name1 := "test_001.png"
  robotgo.SaveCapture(name1, 10, 10, 30, 30)
  robotgo.SaveCapture(name)

  fmt.Print("gcv find image: ")
  fmt.Println(gcv.FindImgFile(name1, name))
  fmt.Println(gcv.FindAllImgFile(name1, name))

  bit := bitmap.Open(name1)
  defer robotgo.FreeBitmap(bit)
  fmt.Print("find bitmap: ")
  fmt.Println(bitmap.Find(bit))

  // bit0 := robotgo.CaptureScreen()
  // img := robotgo.ToImage(bit0)
  // bit1 := robotgo.CaptureScreen(10, 10, 30, 30)
  // img1 := robotgo.ToImage(bit1)
  // defer robotgo.FreeBitmapArr(bit0, bit1)
  img, _ := robotgo.CaptureImg()
  img1, _ := robotgo.CaptureImg(10, 10, 30, 30)

  fmt.Print("gcv find image: ")
  fmt.Println(gcv.FindImg(img1, img))
  fmt.Println()

  res := gcv.FindAllImg(img1, img)
  fmt.Println(res[0].TopLeft.Y, res[0].Rects.TopLeft.X, res)
  x, y := res[0].TopLeft.X, res[0].TopLeft.Y
  robotgo.Move(x, y-rand.Intn(5))
  robotgo.MilliSleep(100)
  robotgo.Click()

  res = gcv.FindAll(img1, img) // 使用模板匹配和SIFT算法
  fmt.Println("find all: ", res)
  res1 := gcv.Find(img1, img)
  fmt.Println("find: ", res1)

  img2, _, _ := robotgo.DecodeImg("test_001.png")
  x, y = gcv.FindX(img2, img)
  fmt.Println(x, y)
}

Event

package main

import (
  "fmt"

  // "github.com/go-vgo/robotgo"
  hook "github.com/robotn/gohook"
)

func main() {
  add()
  low()
  event()
}

func add() {
  fmt.Println("--- 请按 ctrl + shift + q 停止钩子 ---")
  hook.Register(hook.KeyDown, []string{"q", "ctrl", "shift"}, func(e hook.Event) {
    fmt.Println("ctrl-shift-q")
    hook.End()
  })

  fmt.Println("--- 请按 w 键 ---")
  hook.Register(hook.KeyDown, []string{"w"}, func(e hook.Event) {
    fmt.Println("w")
  })

  s := hook.Start()
  <-hook.Process(s)
}

func low() {
	evChan := hook.Start()
	defer hook.End()

	for ev := range evChan {
		fmt.Println("hook: ", ev)
	}
}

func event() {
  ok := hook.AddEvents("q", "ctrl", "shift")
  if ok {
    fmt.Println("add events...")
  }

  keve := hook.AddEvent("k")
  if keve {
    fmt.Println("you press... ", "k")
  }

  mleft := hook.AddEvent("mleft")
  if mleft {
    fmt.Println("you press... ", "鼠标左键")
  }
}

Window

package main

import (
  "fmt"

  "github.com/go-vgo/robotgo"
)

func main() {
  fpid, err := robotgo.FindIds("Google")
  if err == nil {
    fmt.Println("pids... ", fpid)

    if len(fpid) > 0 {
      robotgo.Type("Hi galaxy!", fpid[0])
      robotgo.KeyTap("a", fpid[0], "cmd")

      robotgo.KeyToggle("a", fpid[0])
      robotgo.KeyToggle("a", fpid[0], "up")

      robotgo.ActivePid(fpid[0])

      robotgo.Kill(fpid[0])
    }
  }

  robotgo.ActiveName("chrome")

  isExist, err := robotgo.PidExists(100)
  if err == nil && isExist {
    fmt.Println("pid exists is", isExist)

    robotgo.Kill(100)
  }

  abool := robotgo.Alert("test", "robotgo")
  if abool {
 	  fmt.Println("ok@@@ ", "ok")
  }

  title := robotgo.GetTitle()
  fmt.Println("title@@@ ", title)
}

作者

• 作者是 Evans
• 维护者

计划

• 将部分 C 代码重构为 Go（例如 x11、windows）
• 改进多屏幕支持
• 支持 Wayland
• 更新窗口句柄
• 尝试支持 Android 和 iOS

贡献者

• 完整的贡献者列表请参见 贡献者页面。
• 贡献指南请参见 CONTRIBUTING.md。

许可证

Robotgo 主要根据“Apache 许可证（版本 2.0）”进行分发，其中部分内容受各种类似 BSD 的许可证保护。

详情请参阅 LICENSE-APACHE 和 LICENSE。

RobotGo 快速上手指南

RobotGo 是一个强大的 Golang 桌面自动化库，支持控制鼠标、键盘、读取屏幕、管理窗口进程以及图像识别。适用于 macOS、Windows 和 Linux (X11)。

环境准备

在开始之前，请确保系统已安装 Golang 和 GCC 编译器。不同操作系统的具体依赖如下：

通用要求

• Golang: 建议版本 1.11+
• GCC: C 语言编译器

macOS

1. 安装 Go 和 Xcode 命令行工具：

   brew install go
   xcode-select --install
   

2. 重要权限设置： 前往 系统设置 > 隐私与安全性，在 辅助功能 (Accessibility) 和 屏幕录制 (Screen Recording) 中授予终端或 IDE 相应权限，否则无法控制鼠标或截屏。

Windows

1. 安装 Go：

   winget install Golang.go
   

2. 安装 GCC (推荐 LLVM-MinGW 或 MinGW-w64)：

   winget install MartinStorsjo.LLVM-MinGW.UCRT
   

   或者下载 MinGW-w64 安装包，并将 bin 目录（如 C:\mingw64\bin）添加到系统环境变量 Path 中。

Linux (以 Ubuntu/Debian 为例)

需要安装 X11 开发库、剪贴板工具及图像库：

# 安装 Go (或使用 snap)
sudo apt install golang

# 安装 GCC 及基础开发包
sudo apt install gcc libc6-dev

# 安装 X11 相关依赖
sudo apt install libx11-dev xorg-dev libxtst-dev

# 安装剪贴板工具
sudo apt install xsel xclip

# 安装图像处理和 Hook 相关依赖
sudo apt install libpng++-dev xcb libxcb-xkb-dev x11-xkb-utils libx11-xcb-dev libxkbcommon-x11-dev libxkbcommon-dev

安装步骤

使用 Go Modules 管理项目（推荐），直接在代码中导入即可自动下载；或手动运行以下命令安装：

go get github.com/go-vgo/robotgo

如果在编译时遇到 png.h: No such file or directory 错误，请检查上述“环境准备”中是否已正确安装 libpng 相关开发库。

基本使用

以下是一个最简单的示例，演示如何移动鼠标、点击以及输入文本。

创建 main.go 文件：

package main

import (
	"fmt"
	"github.com/go-vgo/robotgo"
)

func main() {
	// 设置鼠标操作延迟 (毫秒)
	robotgo.MouseSleep = 100

	// 1. 鼠标控制
	// 移动鼠标到坐标 (100, 200)
	robotgo.Move(100, 200)
	
	// 获取当前鼠标位置
	x, y := robotgo.Location()
	fmt.Printf("当前鼠标位置：%d, %d\n", x, y)

	// 左键单击
	robotgo.Click("left")

	// 2. 键盘控制
	// 输入字符串
	robotgo.Type("Hello RobotGo!")
	
	// 模拟按下回车键
	robotgo.KeyTap("enter")

	// 组合键：Alt + Cmd + i (Mac) 或 Alt + Ctrl + i (Win/Linux)
	robotgo.KeyTap("i", "alt", "cmd")

	// 3. 剪贴板操作
	robotgo.WriteAll("这是一段测试文本")
	text, err := robotgo.ReadAll()
	if err == nil {
		fmt.Println("剪贴板内容:", text)
	}
}

运行程序：

go run main.go

注意：在 Linux 环境下运行可能需要设置 DISPLAY 环境变量（例如 export DISPLAY=:0）。在 macOS 上如果程序无反应，请再次检查“隐私与安全性”中的辅助功能权限。