fix: update NetworkConfig type in config.go

Reimplement #141 since we've changed everything since

.devcontainer/docker/devcontainer.json

@@ -1,5 +1,5 @@
 {
-	"name": "JetKVM",
+	"name": "JetKVM docker devcontainer",
 	"image": "mcr.microsoft.com/devcontainers/go:1.25-trixie",
 	"features": {
 		"ghcr.io/devcontainers/features/node:1": {

.devcontainer/install-deps.sh

@@ -32,4 +32,5 @@ wget https://github.com/jetkvm/rv1106-system/releases/download/${BUILDKIT_VERSIO
     sudo mkdir -p /opt/jetkvm-native-buildkit && \
     sudo tar --use-compress-program="unzstd --long=31" -xvf buildkit.tar.zst -C /opt/jetkvm-native-buildkit && \
     rm buildkit.tar.zst
-popd
+popd
+rm -rf "${BUILDKIT_TMPDIR}"

.devcontainer/podman/devcontainer.json

@@ -0,0 +1,19 @@
+{
+	"name": "JetKVM podman devcontainer",
+	"image": "mcr.microsoft.com/devcontainers/go:1.25-trixie",
+	"features": {
+		"ghcr.io/devcontainers/features/node:1": {
+			// Should match what is defined in ui/package.json
+			"version": "22.19.0"
+		}
+	},
+	"runArgs": [
+		"--userns=keep-id",
+		"--security-opt=label=disable",
+		"--security-opt=label=nested"
+	],
+	"containerUser": "vscode",
+	"containerEnv": {
+		"HOME": "/home/vscode"
+	}
+}

config.go

@@ -104,6 +104,7 @@ type Config struct {
 	UsbDevices           *usbgadget.Devices   `json:"usb_devices"`
 	NetworkConfig        *types.NetworkConfig `json:"network_config"`
 	DefaultLogLevel      string               `json:"default_log_level"`
+	VideoSleepAfterSec   int                  `json:"video_sleep_after_sec"`
 }
 
 func (c *Config) GetDisplayRotation() uint16 {

internal/native/native.go

@@ -19,6 +19,7 @@ type Native struct {
 	onVideoFrameReceived func(frame []byte, duration time.Duration)
 	onIndevEvent         func(event string)
 	onRpcEvent           func(event string)
+	sleepModeSupported   bool
 	videoLock            sync.Mutex
 	screenLock           sync.Mutex
 }
@@ -62,6 +63,8 @@ func NewNative(opts NativeOptions) *Native {
 		}
 	}
 
+	sleepModeSupported := isSleepModeSupported()
+
 	return &Native{
 		ready:                make(chan struct{}),
 		l:                    nativeLogger,
@@ -73,6 +76,7 @@ func NewNative(opts NativeOptions) *Native {
 		onVideoFrameReceived: onVideoFrameReceived,
 		onIndevEvent:         onIndevEvent,
 		onRpcEvent:           onRpcEvent,
+		sleepModeSupported:   sleepModeSupported,
 		videoLock:            sync.Mutex{},
 		screenLock:           sync.Mutex{},
 	}

internal/native/video.go

@@ -1,5 +1,12 @@
 package native
 
+import (
+	"os"
+)
+
+const sleepModeFile = "/sys/devices/platform/ff470000.i2c/i2c-4/4-000f/sleep_mode"
+
+// VideoState is the state of the video stream.
 type VideoState struct {
 	Ready          bool    `json:"ready"`
 	Error          string  `json:"error,omitempty"` //no_signal, no_lock, out_of_range
@@ -8,6 +15,58 @@ type VideoState struct {
 	FramePerSecond float64 `json:"fps"`
 }
 
+func isSleepModeSupported() bool {
+	_, err := os.Stat(sleepModeFile)
+	return err == nil
+}
+
+func (n *Native) setSleepMode(enabled bool) error {
+	if !n.sleepModeSupported {
+		return nil
+	}
+
+	bEnabled := "0"
+	if enabled {
+		bEnabled = "1"
+	}
+	return os.WriteFile(sleepModeFile, []byte(bEnabled), 0644)
+}
+
+func (n *Native) getSleepMode() (bool, error) {
+	if !n.sleepModeSupported {
+		return false, nil
+	}
+
+	data, err := os.ReadFile(sleepModeFile)
+	if err == nil {
+		return string(data) == "1", nil
+	}
+
+	return false, nil
+}
+
+// VideoSetSleepMode sets the sleep mode for the video stream.
+func (n *Native) VideoSetSleepMode(enabled bool) error {
+	n.videoLock.Lock()
+	defer n.videoLock.Unlock()
+
+	return n.setSleepMode(enabled)
+}
+
+// VideoGetSleepMode gets the sleep mode for the video stream.
+func (n *Native) VideoGetSleepMode() (bool, error) {
+	n.videoLock.Lock()
+	defer n.videoLock.Unlock()
+
+	return n.getSleepMode()
+}
+
+// VideoSleepModeSupported checks if the sleep mode is supported.
+func (n *Native) VideoSleepModeSupported() bool {
+	return n.sleepModeSupported
+}
+
+// VideoSetQualityFactor sets the quality factor for the video stream.
 func (n *Native) VideoSetQualityFactor(factor float64) error {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
@@ -15,6 +74,7 @@ func (n *Native) VideoSetQualityFactor(factor float64) error {
 	return videoSetStreamQualityFactor(factor)
 }
 
+// VideoGetQualityFactor gets the quality factor for the video stream.
 func (n *Native) VideoGetQualityFactor() (float64, error) {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
@@ -22,6 +82,7 @@ func (n *Native) VideoGetQualityFactor() (float64, error) {
 	return videoGetStreamQualityFactor()
 }
 
+// VideoSetEDID sets the EDID for the video stream.
 func (n *Native) VideoSetEDID(edid string) error {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
@@ -29,6 +90,7 @@ func (n *Native) VideoSetEDID(edid string) error {
 	return videoSetEDID(edid)
 }
 
+// VideoGetEDID gets the EDID for the video stream.
 func (n *Native) VideoGetEDID() (string, error) {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
@@ -36,6 +98,7 @@ func (n *Native) VideoGetEDID() (string, error) {
 	return videoGetEDID()
 }
 
+// VideoLogStatus gets the log status for the video stream.
 func (n *Native) VideoLogStatus() (string, error) {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
@@ -43,6 +106,7 @@ func (n *Native) VideoLogStatus() (string, error) {
 	return videoLogStatus(), nil
 }
 
+// VideoStop stops the video stream.
 func (n *Native) VideoStop() error {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
@@ -51,10 +115,14 @@ func (n *Native) VideoStop() error {
 	return nil
 }
 
+// VideoStart starts the video stream.
 func (n *Native) VideoStart() error {
 	n.videoLock.Lock()
 	defer n.videoLock.Unlock()
 
+	// disable sleep mode before starting video
+	_ = n.setSleepMode(false)
+
 	videoStart()
 	return nil
 }

jsonrpc.go

@@ -1215,6 +1215,8 @@ var rpcHandlers = map[string]RPCHandler{
 	"getEDID":                {Func: rpcGetEDID},
 	"setEDID":                {Func: rpcSetEDID, Params: []string{"edid"}},
 	"getVideoLogStatus":      {Func: rpcGetVideoLogStatus},
+	"getVideoSleepMode":      {Func: rpcGetVideoSleepMode},
+	"setVideoSleepMode":      {Func: rpcSetVideoSleepMode, Params: []string{"duration"}},
 	"getDevChannelState":     {Func: rpcGetDevChannelState},
 	"setDevChannelState":     {Func: rpcSetDevChannelState, Params: []string{"enabled"}},
 	"getLocalVersion":        {Func: rpcGetLocalVersion},

main.go

@@ -75,6 +75,9 @@ func Main() {
 	}
 	initJiggler()
 
+	// start video sleep mode timer
+	startVideoSleepModeTicker()
+
 	go func() {
 		time.Sleep(15 * time.Minute)
 		for {

pkg/nmlite/interface.go

@@ -727,6 +727,20 @@ func (im *InterfaceManager) ReconcileLinkAddrs(addrs []types.IPAddress, family i
 
 // applyDHCPLease applies DHCP lease configuration using ReconcileLinkAddrs
 func (im *InterfaceManager) applyDHCPLease(lease *types.DHCPLease) error {
+	if lease == nil {
+		return fmt.Errorf("DHCP lease is nil")
+	}
+
+	if lease.DHCPClient != "jetdhcpc" {
+		im.logger.Warn().Str("dhcp_client", lease.DHCPClient).Msg("ignoring DHCP lease, not implemented yet")
+		return nil
+	}
+
+	if lease.IsIPv6() {
+		im.logger.Warn().Msg("ignoring IPv6 DHCP lease, not implemented yet")
+		return nil
+	}
+
 	// Convert DHCP lease to IPv4Config
 	ipv4Config := im.convertDHCPLeaseToIPv4Config(lease)
 

pkg/nmlite/jetdhcpc/client.go

@@ -3,19 +3,17 @@ package jetdhcpc
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net"
 	"slices"
 
 	"time"
 
 	"github.com/jetkvm/kvm/internal/sync"
+	"github.com/jetkvm/kvm/pkg/nmlite/link"
 
-	"github.com/go-co-op/gocron/v2"
 	"github.com/insomniacslk/dhcp/dhcpv4"
 	"github.com/insomniacslk/dhcp/dhcpv6"
 	"github.com/jetkvm/kvm/internal/network/types"
-	"github.com/jetkvm/kvm/pkg/nmlite/link"
 	"github.com/rs/zerolog"
 )
 
@@ -83,8 +81,10 @@ type Config struct {
 	UpdateResolvConf func([]string) error
 }
 
+// Client is a DHCP client.
 type Client struct {
 	types.DHCPClient
+
 	ifaces []string
 	cfg    Config
 	l      *zerolog.Logger
@@ -101,24 +101,28 @@ type Client struct {
 	lease4Mu sync.Mutex
 	lease6Mu sync.Mutex
 
-	scheduler gocron.Scheduler
-	stateDir  string
+	timer4   *time.Timer
+	timer6   *time.Timer
+	stateDir string
 }
 
+var (
+	defaultTimerDuration = 1 * time.Second
+	defaultLinkUpTimeout = 30 * time.Second
+)
+
 // NewClient creates a new DHCP client for the given interface.
 func NewClient(ctx context.Context, ifaces []string, c *Config, l *zerolog.Logger) (*Client, error) {
-	scheduler, err := gocron.NewScheduler()
-	if err != nil {
-		return nil, fmt.Errorf("failed to create scheduler: %w", err)
-	}
+	timer4 := time.NewTimer(defaultTimerDuration)
+	timer6 := time.NewTimer(defaultTimerDuration)
 
 	cfg := *c
 	if cfg.LinkUpTimeout == 0 {
-		cfg.LinkUpTimeout = 30 * time.Second
+		cfg.LinkUpTimeout = defaultLinkUpTimeout
 	}
 
 	if cfg.Timeout == 0 {
-		cfg.Timeout = 30 * time.Second
+		cfg.Timeout = defaultLinkUpTimeout
 	}
 
 	if cfg.Retries == 0 {
@@ -126,12 +130,11 @@ func NewClient(ctx context.Context, ifaces []string, c *Config, l *zerolog.Logge
 	}
 
 	return &Client{
-		ctx:       ctx,
-		ifaces:    ifaces,
-		cfg:       cfg,
-		l:         l,
-		scheduler: scheduler,
-		stateDir:  "/run/jetkvm-dhcp",
+		ctx:      ctx,
+		ifaces:   ifaces,
+		cfg:      cfg,
+		l:        l,
+		stateDir: "/run/jetkvm-dhcp",
 
 		currentLease4: nil,
 		currentLease6: nil,
@@ -141,9 +144,45 @@ func NewClient(ctx context.Context, ifaces []string, c *Config, l *zerolog.Logge
 
 		mu:    sync.Mutex{},
 		cfgMu: sync.Mutex{},
+
+		timer4: timer4,
+		timer6: timer6,
 	}, nil
 }
 
+func resetTimer(t *time.Timer, l *zerolog.Logger) {
+	l.Debug().Dur("delay", defaultTimerDuration).Msg("will retry later")
+	t.Reset(defaultTimerDuration)
+}
+
+func (c *Client) requestLoop(t *time.Timer, family int, ifname string) {
+	for range t.C {
+		if _, err := c.ensureInterfaceUp(ifname); err != nil {
+			c.l.Error().Err(err).Msg("failed to ensure interface up")
+			resetTimer(t, c.l)
+			continue
+		}
+
+		var (
+			lease *Lease
+			err   error
+		)
+		switch family {
+		case link.AfInet:
+			lease, err = c.requestLease4(ifname)
+		case link.AfInet6:
+			lease, err = c.requestLease6(ifname)
+		}
+		if err != nil {
+			c.l.Error().Err(err).Msg("failed to request lease")
+			resetTimer(t, c.l)
+			continue
+		}
+
+		c.handleLeaseChange(lease)
+	}
+}
+
 func (c *Client) ensureInterfaceUp(ifname string) (*link.Link, error) {
 	nlm := link.GetNetlinkManager()
 	iface, err := nlm.GetLinkByName(ifname)
@@ -153,76 +192,7 @@ func (c *Client) ensureInterfaceUp(ifname string) (*link.Link, error) {
 	return nlm.EnsureInterfaceUpWithTimeout(c.ctx, iface, c.cfg.LinkUpTimeout)
 }
 
-func (c *Client) sendInitialRequests() chan any {
-	return c.sendRequests(c.cfg.IPv4, c.cfg.IPv6)
-}
-
-func (c *Client) sendRequestsFamily(
-	family int,
-	wg *sync.WaitGroup,
-	r *chan any,
-	l *zerolog.Logger,
-	iface *link.Link,
-) {
-	wg.Add(1)
-	go func(iface *link.Link) {
-		defer wg.Done()
-		var (
-			lease *Lease
-			err   error
-		)
-		switch family {
-		case link.AfInet:
-			lease, err = c.requestLease4(iface)
-		case link.AfInet6:
-			lease, err = c.requestLease6(iface)
-		}
-		if err != nil {
-			l.Error().Err(err).Msg("Could not get lease")
-			return
-		}
-		(*r) <- lease
-	}(iface)
-}
-
-func (c *Client) sendRequests(ipv4, ipv6 bool) chan any {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Yeah, this is a hack, until we can cancel all leases in progress.
-	r := make(chan any, 3*len(c.ifaces))
-
-	var wg sync.WaitGroup
-	for _, iface := range c.ifaces {
-		wg.Add(1)
-		go func(ifname string) {
-			defer wg.Done()
-
-			l := c.l.With().Str("interface", ifname).Logger()
-
-			iface, err := c.ensureInterfaceUp(ifname)
-			if err != nil {
-				l.Error().Err(err).Msg("Could not bring up interface")
-				return
-			}
-
-			if ipv4 {
-				c.sendRequestsFamily(link.AfInet, &wg, &r, &l, iface)
-			}
-
-			if ipv6 {
-				c.sendRequestsFamily(link.AfInet6, &wg, &r, &l, iface)
-			}
-		}(iface)
-	}
-
-	go func() {
-		wg.Wait()
-		close(r)
-	}()
-	return r
-}
-
+// Lease4 returns the current IPv4 lease
 func (c *Client) Lease4() *types.DHCPLease {
 	c.lease4Mu.Lock()
 	defer c.lease4Mu.Unlock()
@@ -234,6 +204,7 @@ func (c *Client) Lease4() *types.DHCPLease {
 	return c.currentLease4.ToDHCPLease()
 }
 
+// Lease6 returns the current IPv6 lease
 func (c *Client) Lease6() *types.DHCPLease {
 	c.lease6Mu.Lock()
 	defer c.lease6Mu.Unlock()
@@ -245,6 +216,7 @@ func (c *Client) Lease6() *types.DHCPLease {
 	return c.currentLease6.ToDHCPLease()
 }
 
+// Domain returns the current domain
 func (c *Client) Domain() string {
 	c.lease4Mu.Lock()
 	defer c.lease4Mu.Unlock()
@@ -263,50 +235,23 @@ func (c *Client) Domain() string {
 	return ""
 }
 
+// handleLeaseChange handles lease changes
 func (c *Client) handleLeaseChange(lease *Lease) {
 	// do not use defer here, because we need to unlock the mutex before returning
-
 	ipv4 := lease.p4 != nil
-	version := "ipv4"
 
 	if ipv4 {
 		c.lease4Mu.Lock()
 		c.currentLease4 = lease
+		c.lease4Mu.Unlock()
 	} else {
-		version = "ipv6"
 		c.lease6Mu.Lock()
 		c.currentLease6 = lease
-	}
-
-	// clear all current jobs with the same tags
-	// c.scheduler.RemoveByTags(version)
-
-	// add scheduler job to renew the lease
-	if lease.RenewalTime > 0 {
-		c.scheduler.NewJob(
-			gocron.DurationJob(time.Duration(lease.RenewalTime)*time.Second),
-			gocron.NewTask(func() {
-				c.l.Info().Msg("renewing lease")
-				for lease := range c.sendRequests(ipv4, !ipv4) {
-					if lease, ok := lease.(*Lease); ok {
-						c.handleLeaseChange(lease)
-					}
-				}
-			}),
-			gocron.WithName(fmt.Sprintf("renew-%s", version)),
-			gocron.WithSingletonMode(gocron.LimitModeWait),
-			gocron.WithTags(version),
-		)
+		c.lease6Mu.Unlock()
 	}
 
 	c.apply()
 
-	if ipv4 {
-		c.lease4Mu.Unlock()
-	} else {
-		c.lease6Mu.Unlock()
-	}
-
 	// TODO: handle lease expiration
 	if c.cfg.OnLease4Change != nil && ipv4 {
 		c.cfg.OnLease4Change(lease.ToDHCPLease())
@@ -317,14 +262,23 @@ func (c *Client) handleLeaseChange(lease *Lease) {
 	}
 }
 
-func (c *Client) renew() {
-	for lease := range c.sendRequests(c.cfg.IPv4, c.cfg.IPv6) {
-		if lease, ok := lease.(*Lease); ok {
-			c.handleLeaseChange(lease)
-		}
+func (c *Client) doRenewLoop() {
+	timer := time.NewTimer(time.Duration(c.currentLease4.RenewalTime) * time.Second)
+	defer timer.Stop()
+
+	for range timer.C {
+		c.renew()
 	}
 }
 
+func (c *Client) renew() {
+	// for lease := range c.sendRequests(c.cfg.IPv4, c.cfg.IPv6) {
+	// 	if lease, ok := lease.(*Lease); ok {
+	// 		c.handleLeaseChange(lease)
+	// 	}
+	// }
+}
+
 func (c *Client) Renew() error {
 	go c.renew()
 	return nil
@@ -350,17 +304,29 @@ func (c *Client) SetIPv4(ipv4 bool) {
 		c.lease4Mu.Lock()
 		c.currentLease4 = nil
 		c.lease4Mu.Unlock()
-		c.scheduler.RemoveByTags("ipv4")
 	}
 
-	c.sendRequests(ipv4, c.cfg.IPv6)
+	c.timer4.Stop()
 }
 
 func (c *Client) SetIPv6(ipv6 bool) {
 	c.cfgMu.Lock()
 	defer c.cfgMu.Unlock()
 
+	currentIPv6 := c.cfg.IPv6
 	c.cfg.IPv6 = ipv6
+
+	if currentIPv6 == ipv6 {
+		return
+	}
+
+	if !ipv6 {
+		c.lease6Mu.Lock()
+		c.currentLease6 = nil
+		c.lease4Mu.Unlock()
+	}
+
+	c.timer6.Stop()
 }
 
 func (c *Client) Start() error {
@@ -368,15 +334,14 @@ func (c *Client) Start() error {
 		c.l.Warn().Err(err).Msg("failed to kill udhcpc processes, continuing anyway")
 	}
 
-	c.scheduler.Start()
-
-	go func() {
-		for lease := range c.sendInitialRequests() {
-			if lease, ok := lease.(*Lease); ok {
-				c.handleLeaseChange(lease)
-			}
+	for _, iface := range c.ifaces {
+		if c.cfg.IPv4 {
+			go c.requestLoop(c.timer4, link.AfInet, iface)
 		}
-	}()
+		if c.cfg.IPv6 {
+			go c.requestLoop(c.timer6, link.AfInet6, iface)
+		}
+	}
 
 	return nil
 }

pkg/nmlite/jetdhcpc/dhcp4.go

@@ -8,8 +8,12 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-func (c *Client) requestLease4(iface netlink.Link) (*Lease, error) {
-	ifname := iface.Attrs().Name
+func (c *Client) requestLease4(ifname string) (*Lease, error) {
+	iface, err := netlink.LinkByName(ifname)
+	if err != nil {
+		return nil, err
+	}
+
 	l := c.l.With().Str("interface", ifname).Logger()
 
 	mods := []nclient4.ClientOpt{

pkg/nmlite/jetdhcpc/dhcp6.go

@@ -55,10 +55,14 @@ func isIPv6RouteReady(serverAddr net.IP) waitForCondition {
 	}
 }
 
-func (c *Client) requestLease6(iface netlink.Link) (*Lease, error) {
-	ifname := iface.Attrs().Name
+func (c *Client) requestLease6(ifname string) (*Lease, error) {
 	l := c.l.With().Str("interface", ifname).Logger()
 
+	iface, err := netlink.LinkByName(ifname)
+	if err != nil {
+		return nil, err
+	}
+
 	clientPort := dhcpv6.DefaultClientPort
 	if c.cfg.V6ClientPort != nil {
 		clientPort = *c.cfg.V6ClientPort

ui/src/routes/devices.$id.mount.tsx

@@ -374,8 +374,8 @@ function UrlView({
       icon: FedoraIcon,
     },
     {
-      name: "openSUSE Leap 15.6",
-      url: "https://download.opensuse.org/distribution/leap/15.6/iso/openSUSE-Leap-15.6-NET-x86_64-Media.iso",
+      name: "openSUSE Leap 16.0",
+      url: "https://download.opensuse.org/distribution/leap/16.0/offline/Leap-16.0-online-installer-x86_64.install.iso",
       icon: OpenSUSEIcon,
     },
     {

video.go

@@ -1,10 +1,22 @@
 package kvm
 
 import (
+	"context"
+	"fmt"
+	"time"
+
 	"github.com/jetkvm/kvm/internal/native"
 )
 
-var lastVideoState native.VideoState
+var (
+	lastVideoState       native.VideoState
+	videoSleepModeCtx    context.Context
+	videoSleepModeCancel context.CancelFunc
+)
+
+const (
+	defaultVideoSleepModeDuration = 1 * time.Minute
+)
 
 func triggerVideoStateUpdate() {
 	go func() {
@@ -17,3 +29,92 @@ func triggerVideoStateUpdate() {
 func rpcGetVideoState() (native.VideoState, error) {
 	return lastVideoState, nil
 }
+
+type rpcVideoSleepModeResponse struct {
+	Supported bool `json:"supported"`
+	Enabled   bool `json:"enabled"`
+	Duration  int  `json:"duration"`
+}
+
+func rpcGetVideoSleepMode() rpcVideoSleepModeResponse {
+	sleepMode, _ := nativeInstance.VideoGetSleepMode()
+	return rpcVideoSleepModeResponse{
+		Supported: nativeInstance.VideoSleepModeSupported(),
+		Enabled:   sleepMode,
+		Duration:  config.VideoSleepAfterSec,
+	}
+}
+
+func rpcSetVideoSleepMode(duration int) error {
+	if duration < 0 {
+		duration = -1 // disable
+	}
+
+	config.VideoSleepAfterSec = duration
+	if err := SaveConfig(); err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+
+	// we won't restart the ticker here,
+	// as the session can't be inactive when this function is called
+	return nil
+}
+
+func stopVideoSleepModeTicker() {
+	nativeLogger.Trace().Msg("stopping HDMI sleep mode ticker")
+
+	if videoSleepModeCancel != nil {
+		nativeLogger.Trace().Msg("canceling HDMI sleep mode ticker context")
+		videoSleepModeCancel()
+		videoSleepModeCancel = nil
+		videoSleepModeCtx = nil
+	}
+}
+
+func startVideoSleepModeTicker() {
+	if !nativeInstance.VideoSleepModeSupported() {
+		return
+	}
+
+	var duration time.Duration
+
+	if config.VideoSleepAfterSec == 0 {
+		duration = defaultVideoSleepModeDuration
+	} else if config.VideoSleepAfterSec > 0 {
+		duration = time.Duration(config.VideoSleepAfterSec) * time.Second
+	} else {
+		stopVideoSleepModeTicker()
+		return
+	}
+
+	// Stop any existing timer and goroutine
+	stopVideoSleepModeTicker()
+
+	// Create new context for this ticker
+	videoSleepModeCtx, videoSleepModeCancel = context.WithCancel(context.Background())
+
+	go doVideoSleepModeTicker(videoSleepModeCtx, duration)
+}
+
+func doVideoSleepModeTicker(ctx context.Context, duration time.Duration) {
+	timer := time.NewTimer(duration)
+	defer timer.Stop()
+
+	nativeLogger.Trace().Msg("HDMI sleep mode ticker started")
+
+	for {
+		select {
+		case <-timer.C:
+			if getActiveSessions() > 0 {
+				nativeLogger.Warn().Msg("not going to enter HDMI sleep mode because there are active sessions")
+				continue
+			}
+
+			nativeLogger.Trace().Msg("entering HDMI sleep mode")
+			_ = nativeInstance.VideoSetSleepMode(true)
+		case <-ctx.Done():
+			nativeLogger.Trace().Msg("HDMI sleep mode ticker stopped")
+			return
+		}
+	}
+}

webrtc.go

@@ -39,6 +39,34 @@ type Session struct {
 	keysDownStateQueue chan usbgadget.KeysDownState
 }
 
+var (
+	actionSessions      int = 0
+	activeSessionsMutex     = &sync.Mutex{}
+)
+
+func incrActiveSessions() int {
+	activeSessionsMutex.Lock()
+	defer activeSessionsMutex.Unlock()
+
+	actionSessions++
+	return actionSessions
+}
+
+func decrActiveSessions() int {
+	activeSessionsMutex.Lock()
+	defer activeSessionsMutex.Unlock()
+
+	actionSessions--
+	return actionSessions
+}
+
+func getActiveSessions() int {
+	activeSessionsMutex.Lock()
+	defer activeSessionsMutex.Unlock()
+
+	return actionSessions
+}
+
 func (s *Session) resetKeepAliveTime() {
 	s.keepAliveJitterLock.Lock()
 	defer s.keepAliveJitterLock.Unlock()
@@ -312,9 +340,8 @@ func newSession(config SessionConfig) (*Session, error) {
 		if connectionState == webrtc.ICEConnectionStateConnected {
 			if !isConnected {
 				isConnected = true
-				actionSessions++
 				onActiveSessionsChanged()
-				if actionSessions == 1 {
+				if incrActiveSessions() == 1 {
 					onFirstSessionConnected()
 				}
 			}
@@ -353,9 +380,8 @@ func newSession(config SessionConfig) (*Session, error) {
 			}
 			if isConnected {
 				isConnected = false
-				actionSessions--
 				onActiveSessionsChanged()
-				if actionSessions == 0 {
+				if decrActiveSessions() == 0 {
 					onLastSessionDisconnected()
 				}
 			}
@@ -364,16 +390,16 @@ func newSession(config SessionConfig) (*Session, error) {
 	return session, nil
 }
 
-var actionSessions = 0
-
 func onActiveSessionsChanged() {
 	requestDisplayUpdate(true, "active_sessions_changed")
 }
 
 func onFirstSessionConnected() {
 	_ = nativeInstance.VideoStart()
+	stopVideoSleepModeTicker()
 }
 
 func onLastSessionDisconnected() {
 	_ = nativeInstance.VideoStop()
+	startVideoSleepModeTicker()
 }