使用Go语言调用Windows API：获取系统空闲时间教程

package main

import (
    "fmt"
    "syscall"
    "time"
    "unsafe" // 用于处理指针和结构体大小
)

// 定义Windows API所需的结构体
// LASTINPUTINFO 结构体，用于GetLastInputInfo函数
// cbSize 字段必须初始化为结构体的大小
// dwTime 字段表示上次输入事件发生的时间（毫秒）
type LASTINPUTINFO struct {
    cbSize uint32
    dwTime uint32
}

func main() {
    // 1. 加载user32.dll
    // MustLoadDLL 会在加载失败时panic，如果需要更细致的错误处理，可以使用 syscall.LoadDLL
    user32 := syscall.MustLoadDLL("user32.dll")
    defer user32.Release() // 确保DLL在程序结束时释放

    // 2. 查找GetLastInputInfo函数
    // MustFindProc 会在查找失败时panic，如果需要更细致的错误处理，可以使用 user32.FindProc
    getLastInputInfo := user32.MustFindProc("GetLastInputInfo")

    fmt.Println("DLL和函数加载成功。")

    // 后续步骤将在此处继续，处理结构体和函数调用
}

typedef struct tagLASTINPUTINFO {
  UINT  cbSize;
  DWORD dwTime;
} LASTINPUTINFO, *PLASTINPUTINFO;

// 定义Windows API所需的结构体
type LASTINPUTINFO struct {
    cbSize uint32 // 对应Windows API的UINT (通常是32位)
    dwTime uint32 // 对应Windows API的DWORD (32位)
}

// ... 在main函数中 ...

var lastInputInfo LASTINPUTINFO
// 初始化cbSize字段，这是Windows API的常见要求
lastInputInfo.cbSize = uint32(unsafe.Sizeof(lastInputInfo))

// ...

// ... 在main函数中 ...

// 调用GetLastInputInfo函数，传递lastInputInfo结构体的指针
// unsafe.Pointer(&lastInputInfo) 将结构体变量的地址转换为通用指针
// uintptr(...) 将通用指针转换为syscall.Call所需的uintptr类型
r1, _, callErr := getLastInputInfo.Call(uintptr(unsafe.Pointer(&lastInputInfo)))

// 根据GetLastInputInfo的文档，如果成功，返回非零值；如果失败，返回零。
if r1 == 0 {
    // 如果r1为0，表示函数调用失败。callErr可能包含更多系统错误信息。
    // 在某些情况下，即使r1为0，callErr也可能是nil，因为它只反映底层的syscall错误。
    // 真正的API错误通常需要通过GetLastError()获取，但Go的syscall.Call已经包装了。
    panic(fmt.Sprintf("调用GetLastInputInfo失败，返回值r1=0，错误: %v", callErr))
}

// 成功获取到信息，lastInputInfo.dwTime现在包含了上次输入事件的时间
fmt.Printf("上次输入事件发生时间（毫秒）：%d\n", lastInputInfo.dwTime)

// ...

package main

import (
    "fmt"
    "syscall"
    "time"
    "unsafe"
)

// LASTINPUTINFO 结构体定义，用于GetLastInputInfo函数
type LASTINPUTINFO struct {
    cbSize uint32
    dwTime uint32
}

// GetWindowsIdleTime 获取Windows系统的空闲时间
// 返回空闲时间（time.Duration）和可能的错误
func GetWindowsIdleTime() (time.Duration, error) {
    // 1. 加载user32.dll
    user32 := syscall.MustLoadDLL("user32.dll")
    defer user32.Release()

    // 2. 查找GetLastInputInfo函数
    getLastInputInfo := user32.MustFindProc("GetLastInputInfo")

    // 3. 准备LASTINPUTINFO结构体
    var lastInputInfo LASTINPUTINFO
    lastInputInfo.cbSize = uint32(unsafe.Sizeof(lastInputInfo))

    // 4. 调用GetLastInputInfo函数
    r1, _, callErr := getLastInputInfo.Call(uintptr(unsafe.Pointer(&lastInputInfo)))

    // 5. 检查函数调用结果
    // GetLastInputInfo函数在成功时返回非零值，失败时返回零。
    if r1 == 0 {
        return 0, fmt.Errorf("调用GetLastInputInfo失败，返回值r1=0，错误: %v", callErr)
    }

    // 6. 获取当前系统启动后的毫秒数
    // GetTickCount函数返回系统启动后的毫秒数，但它在64位系统上可能溢出。
    // 更好的做法是使用GetTickCount64或直接计算空闲时间。
    // 这里我们假设lastInputInfo.dwTime是相对于系统启动时间的毫秒数。
    // 实际空闲时间 = 当前系统运行时间 - 上次输入事件时间
    // 但Windows API的GetLastInputInfo.dwTime已经是自系统启动以来的毫秒数。
    // 所以，空闲时间就是当前系统启动后的毫秒数 - lastInputInfo.dwTime
    // 实际上，dwTime就是上次输入的时间点。
    // Current time in ms from system start (approx)
    // For simplicity, we can get current system time in ms and subtract dwTime
    // A more accurate way might involve GetTickCount64 or similar if available,
    // but dwTime itself is the timestamp.
    // The problem statement implies getting the *idle duration*.
    // The system uptime in milliseconds can be obtained via GetTickCount().
    // Idle time = current_tick_count - last_input_info.dwTime

    // GetTickCount() is a 32-bit value, can overflow. GetTickCount64() is better.
    // For simplicity and matching common interpretations of idle time:
    // current_tick_count := syscall.GetTickCount() // This is not directly available in syscall for Windows
    // We need to call another API for current tick count.
    // Let's assume for this example, the question implies lastInputInfo.dwTime is enough to calculate.
    // The typical calculation is: current_uptime_ms - lastInputInfo.dwTime.
    // For this tutorial, let's use a simplified approach assuming we want the duration from the last input.
    // A more robust solution would involve calling GetTickCount64.

    // For demonstration, let's just return the dwTime as the "last input time".
    // To get idle *duration*, we need current system uptime.
    // Let's call GetTickCount() via syscall for completeness.
    kernel32 := syscall.MustLoadDLL("kernel32.dll")
    defer kernel32.Release()
    getTickCount := kernel32.MustFindProc("GetTickCount")

    r2, _, _ := getTickCount.Call()
    currentTickCount := uint32(r2) // GetTickCount returns DWORD (uint32)

    idleMilliseconds := currentTickCount - lastInputInfo.dwTime

    return time.Duration(idleMilliseconds) * time.Millisecond, nil
}

func main() {
    idleTime, err := GetWindowsIdleTime()
    if err != nil {
        fmt.Printf("获取Windows空闲时间失败: %v\n", err)
        return
    }
    fmt.Printf("Windows系统空闲时间: %v\n", idleTime)
}

go run idle_time.go

Windows系统空闲时间: 5m12s