Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

3.9 KB
Raw Blame
//go:build windows

package remoteinput

import (
	"runtime"
	"strconv"
	"testing"
	"unsafe"

	"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
	"golang.org/x/sys/windows"
)

func TestWindowTargetObservations(t *testing.T) {
	// A hidden zero-style fixture never activates or injects desktop input.
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	class, _ := windows.UTF16PtrFromString("STATIC")
	window, _, err := user32.NewProc("CreateWindowExW").Call(0, uintptr(unsafe.Pointer(class)), 0, 0x80000000, 0, 0, 320, 200, 0, 0, 0, 0)
	if window == 0 {
		t.Fatalf("create hidden fixture: %v", err)
	}
	defer func() {
		if window != 0 {
			user32.NewProc("DestroyWindow").Call(window)
		}
	}()
	var pid uint32
	user32.NewProc("GetWindowThreadProcessId").Call(window, uintptr(unsafe.Pointer(&pid)))
	var created, exited, kernel, user windows.Filetime
	process, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, pid)
	if err != nil {
		t.Fatal(err)
	}
	defer windows.CloseHandle(process)
	if err := windows.GetProcessTimes(process, &created, &exited, &kernel, &user); err != nil {
		t.Fatal(err)
	}
	target := nativecapture.CaptureTarget{Kind: "window", SourceID: strconv.FormatUint(uint64(window), 10), PID: pid, CreationTime: strconv.FormatUint(uint64(created.HighDateTime)<<32|uint64(created.LowDateTime), 10)}
	sink := &windowsSink{}
	if b, _, err := sink.Target(target, nil); err != nil || b.width <= 0 || b.height <= 0 {
		t.Fatalf("valid geometry: %+v %v", b, err)
	}
	user32.NewProc("SetWindowPos").Call(window, 0, 0, 0, 0, 0, 0x0014) // NOZORDER | NOACTIVATE
	if b, focused, err := sink.Target(target, nil); err != nil || focused || b != (bounds{}) {
		t.Fatalf("empty geometry must suspend: %+v %v %v", b, focused, err)
	}
	user32.NewProc("SetWindowPos").Call(window, 0, 0, 0, 320, 200, 0x0014)
	if b, _, err := sink.Target(target, nil); err != nil || b.width <= 0 {
		t.Fatalf("geometry did not recover: %+v %v", b, err)
	}
	target.CreationTime = "1"
	if _, _, err := sink.Target(target, nil); err == nil {
		t.Fatal("replaced process identity accepted")
	}
	target.PID++
	if _, _, err := sink.Target(target, nil); err == nil {
		t.Fatal("different window owner accepted")
	}
	user32.NewProc("DestroyWindow").Call(window)
	window = 0
	if _, _, err := sink.Target(target, nil); err == nil {
		t.Fatal("destroyed window accepted")
	}
}

type monitorObservationSink struct {
	*recordedInput
	unavailable bool
}

func (s *monitorObservationSink) Target(target nativecapture.CaptureTarget, stream *nativecapture.Stream) (bounds, bool, error) {
	if s.unavailable {
		target.SourceID = "1"
	}
	return (&windowsSink{}).Target(target, stream)
}

func TestMonitorObservationSuspendsSameGrant(t *testing.T) {
	monitor, _, _ := user32.NewProc("MonitorFromPoint").Call(0, 1)
	if monitor == 0 {
		t.Skip("no interactive display")
	}
	sink := &monitorObservationSink{recordedInput: &recordedInput{events: make(chan inputEvent, 16), resets: make(chan struct{}, 16), focused: true}}
	m := &Manager{sink: sink, connections: map[endpointKey]*connection{}}
	s, peers := coPlaySession(t, m, true)
	s.target = nativecapture.CaptureTarget{Kind: "display", SourceID: strconv.FormatUint(uint64(monitor), 10)}
	c := peers[0]
	sendTestInput(m, c, inputEvent{Type: "request"})
	grant := c.grant
	sendTestInput(m, c, inputEvent{Type: "key", Code: "KeyA", Down: true})
	<-sink.events
	sink.unavailable = true
	m.refreshActive()
	sendTestInput(m, c, inputEvent{Type: "move", X: .8, Y: .4})
	if grant == "" || c.grant != grant || !c.suspended || len(c.keys) != 0 || len(sink.events) != 0 {
		t.Fatal("unavailable monitor did not safely suspend same grant")
	}
	sink.unavailable = false
	m.refreshActive()
	if c.suspended || c.grant != grant || len(sink.events) != 0 {
		t.Fatal("monitor recovery changed grant or replayed input")
	}
	sendTestInput(m, c, inputEvent{Type: "move", X: .4, Y: .2})
	if len(sink.events) != 1 {
		t.Fatal("new input did not resume after monitor observation")
	}
}