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
package remoteinput

import (
	"errors"
	"fmt"
)

type controllerTextSink struct {
	manager    *Manager
	controller *connection
}

func (s controllerTextSink) Reset() error { return s.manager.resetHeld(s.controller.owner) }
func (s controllerTextSink) Apply(b bounds, event inputEvent) error {
	return s.manager.applyHeld(s.controller, b, event)
}

// Whole-source cleanup may use the platform's tracked physical state. Keep the
// logical release debt until Reset actually succeeds, including after retirement.
func (m *Manager) resetHeld(s *Session) error {
	if m.pendingKeys == nil {
		m.pendingKeys = make(map[string]bool)
	}
	if m.pendingButtons == nil {
		m.pendingButtons = make(map[int]bool)
	}
	for _, c := range m.connections {
		if c.owner != s {
			continue
		}
		for key := range c.keys {
			m.pendingKeys[key] = true
		}
		for button := range c.buttons {
			m.pendingButtons[button] = true
		}
		c.keys, c.buttons = nil, nil
	}
	err := m.sink.Reset()
	if err == nil {
		clear(m.pendingKeys)
		clear(m.pendingButtons)
	}
	return err
}

// Failed releases outlive their departing controller. Only releases are retried;
// pointer movement, presses and committed text are never replayed.
func (m *Manager) releaseKey(code string) error {
	err := m.applyInput(bounds{}, inputEvent{Type: "key", Code: code})
	if err != nil {
		if m.pendingKeys == nil {
			m.pendingKeys = make(map[string]bool)
		}
		m.pendingKeys[code] = true
	} else {
		delete(m.pendingKeys, code)
	}
	return err
}

func (m *Manager) releaseButton(button int) error {
	err := m.applyInput(bounds{}, inputEvent{Type: "button", Button: button})
	if err != nil {
		if m.pendingButtons == nil {
			m.pendingButtons = make(map[int]bool)
		}
		m.pendingButtons[button] = true
	} else {
		delete(m.pendingButtons, button)
	}
	return err
}

func (m *Manager) retryReleases() error {
	var result error
	for code := range m.pendingKeys {
		if err := m.releaseKey(code); err != nil {
			result = errors.Join(result, fmt.Errorf("key release retry: %w", err))
		}
	}
	for button := range m.pendingButtons {
		if err := m.releaseButton(button); err != nil {
			result = errors.Join(result, fmt.Errorf("button release retry: %w", err))
		}
	}
	return result
}

func (m *Manager) noteInputResult(c *connection, err error) {
	failed := err != nil
	if c.inputFailed != failed {
		c.inputFailed = failed
		m.send(c, m.state(c))
	}
}

func (m *Manager) applyHeld(c *connection, b bounds, event inputEvent) error {
	releaseErr := m.retryReleases()
	releasing := (event.Type == "key" || event.Type == "button") && !event.Down
	if !releasing && (len(m.pendingKeys) != 0 || len(m.pendingButtons) != 0) {
		return fmt.Errorf("held input cleanup is unavailable (%d key, %d button releases pending): %w", len(m.pendingKeys), len(m.pendingButtons), releaseErr)
	}
	switch event.Type {
	case "key":
		if event.Code == "" || len(event.Code) > 32 || event.Down && len(c.keys) >= 256 && !c.keys[event.Code] {
			return nil
		}
		if event.Down {
			// A repeat from this holder is input; another holder shares the press.
			if c.keys[event.Code] || !m.keyHeld(event.Code) {
				if err := m.applyInput(b, event); err != nil {
					return err
				}
			}
			if c.keys == nil {
				c.keys = make(map[string]bool)
			}
			c.keys[event.Code] = true
		} else {
			if !c.keys[event.Code] {
				return nil
			}
			delete(c.keys, event.Code)
			if !m.keyHeld(event.Code) {
				return m.releaseKey(event.Code)
			}
		}
	case "button":
		if event.Button < 0 || event.Button > 4 || c.buttons[event.Button] == event.Down {
			return nil
		}
		if event.Down {
			if !m.buttonHeld(event.Button) {
				if err := m.applyInput(b, event); err != nil {
					return err
				}
			}
			if c.buttons == nil {
				c.buttons = make(map[int]bool)
			}
			c.buttons[event.Button] = true
		} else {
			delete(c.buttons, event.Button)
			if !m.buttonHeld(event.Button) {
				return m.releaseButton(event.Button)
			}
		}
	default:
		return m.applyInput(b, event)
	}
	return nil
}