.devcontainer/devcontainer.json

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

.devcontainer/install-deps.sh

@@ -32,5 +32,4 @@ 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

@@ -1,19 +0,0 @@
-{
-	"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,7 +104,6 @@ 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,7 +19,6 @@ 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
 }
@@ -63,8 +62,6 @@ func NewNative(opts NativeOptions) *Native {
 		}
 	}
 
-	sleepModeSupported := isSleepModeSupported()
-
 	return &Native{
 		ready:                make(chan struct{}),
 		l:                    nativeLogger,
@@ -76,7 +73,6 @@ func NewNative(opts NativeOptions) *Native {
 		onVideoFrameReceived: onVideoFrameReceived,
 		onIndevEvent:         onIndevEvent,
 		onRpcEvent:           onRpcEvent,
-		sleepModeSupported:   sleepModeSupported,
 		videoLock:            sync.Mutex{},
 		screenLock:           sync.Mutex{},
 	}

internal/native/video.go

@@ -1,12 +1,5 @@
 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
@@ -15,58 +8,6 @@ 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()
@@ -74,7 +15,6 @@ 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()
@@ -82,7 +22,6 @@ 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()
@@ -90,7 +29,6 @@ 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()
@@ -98,7 +36,6 @@ 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()
@@ -106,7 +43,6 @@ 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()
@@ -115,14 +51,10 @@ 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,8 +1215,6 @@ 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,9 +75,6 @@ func Main() {
 	}
 	initJiggler()
 
-	// start video sleep mode timer
-	startVideoSleepModeTicker()
-
 	go func() {
 		time.Sleep(15 * time.Minute)
 		for {

pkg/nmlite/interface.go

@@ -727,20 +727,6 @@ 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,17 +3,19 @@ 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"
 )
 
@@ -81,10 +83,8 @@ 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,28 +101,24 @@ type Client struct {
 	lease4Mu sync.Mutex
 	lease6Mu sync.Mutex
 
-	timer4   *time.Timer
+	scheduler gocron.Scheduler
-	timer6   *time.Timer
+	stateDir  string
-	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) {
-	timer4 := time.NewTimer(defaultTimerDuration)
+	scheduler, err := gocron.NewScheduler()
-	timer6 := time.NewTimer(defaultTimerDuration)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create scheduler: %w", err)
+	}
 
 	cfg := *c
 	if cfg.LinkUpTimeout == 0 {
-		cfg.LinkUpTimeout = defaultLinkUpTimeout
+		cfg.LinkUpTimeout = 30 * time.Second
 	}
 
 	if cfg.Timeout == 0 {
-		cfg.Timeout = defaultLinkUpTimeout
+		cfg.Timeout = 30 * time.Second
 	}
 
 	if cfg.Retries == 0 {
@@ -130,11 +126,12 @@ func NewClient(ctx context.Context, ifaces []string, c *Config, l *zerolog.Logge
 	}
 
 	return &Client{
-		ctx:      ctx,
+		ctx:       ctx,
-		ifaces:   ifaces,
+		ifaces:    ifaces,
-		cfg:      cfg,
+		cfg:       cfg,
-		l:        l,
+		l:         l,
-		stateDir: "/run/jetkvm-dhcp",
+		scheduler: scheduler,
+		stateDir:  "/run/jetkvm-dhcp",
 
 		currentLease4: nil,
 		currentLease6: nil,
@@ -144,45 +141,9 @@ 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)
@@ -192,7 +153,76 @@ func (c *Client) ensureInterfaceUp(ifname string) (*link.Link, error) {
 	return nlm.EnsureInterfaceUpWithTimeout(c.ctx, iface, c.cfg.LinkUpTimeout)
 }
 
-// Lease4 returns the current IPv4 lease
+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
+}
+
 func (c *Client) Lease4() *types.DHCPLease {
 	c.lease4Mu.Lock()
 	defer c.lease4Mu.Unlock()
@@ -204,7 +234,6 @@ 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()
@@ -216,7 +245,6 @@ 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()
@@ -235,23 +263,50 @@ 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
-		c.lease6Mu.Unlock()
+	}
+
+	// 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.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())
@@ -262,21 +317,12 @@ func (c *Client) handleLeaseChange(lease *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) {
+	for lease := range c.sendRequests(c.cfg.IPv4, c.cfg.IPv6) {
-	// 	if lease, ok := lease.(*Lease); ok {
+		if lease, ok := lease.(*Lease); ok {
-	// 		c.handleLeaseChange(lease)
+			c.handleLeaseChange(lease)
-	// 	}
+		}
-	// }
+	}
 }
 
 func (c *Client) Renew() error {
@@ -304,29 +350,17 @@ func (c *Client) SetIPv4(ipv4 bool) {
 		c.lease4Mu.Lock()
 		c.currentLease4 = nil
 		c.lease4Mu.Unlock()
+		c.scheduler.RemoveByTags("ipv4")
 	}
 
-	c.timer4.Stop()
+	c.sendRequests(ipv4, c.cfg.IPv6)
 }
 
 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 {
@@ -334,14 +368,15 @@ func (c *Client) Start() error {
 		c.l.Warn().Err(err).Msg("failed to kill udhcpc processes, continuing anyway")
 	}
 
-	for _, iface := range c.ifaces {
+	c.scheduler.Start()
-		if c.cfg.IPv4 {
+
-			go c.requestLoop(c.timer4, link.AfInet, iface)
+	go func() {
+		for lease := range c.sendInitialRequests() {
+			if lease, ok := lease.(*Lease); ok {
+				c.handleLeaseChange(lease)
+			}
 		}
-		if c.cfg.IPv6 {
+	}()
-			go c.requestLoop(c.timer6, link.AfInet6, iface)
-		}
-	}
 
 	return nil
 }

pkg/nmlite/jetdhcpc/dhcp4.go

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

pkg/nmlite/jetdhcpc/dhcp6.go

@@ -55,14 +55,10 @@ func isIPv6RouteReady(serverAddr net.IP) waitForCondition {
 	}
 }
 
-func (c *Client) requestLease6(ifname string) (*Lease, error) {
+func (c *Client) requestLease6(iface netlink.Link) (*Lease, error) {
+	ifname := iface.Attrs().Name
 	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 16.0",
+      name: "openSUSE Leap 15.6",
-      url: "https://download.opensuse.org/distribution/leap/16.0/offline/Leap-16.0-online-installer-x86_64.install.iso",
+      url: "https://download.opensuse.org/distribution/leap/15.6/iso/openSUSE-Leap-15.6-NET-x86_64-Media.iso",
       icon: OpenSUSEIcon,
     },
     {

video.go

@@ -1,22 +1,10 @@
 package kvm
 
 import (
-	"context"
-	"fmt"
-	"time"
-
 	"github.com/jetkvm/kvm/internal/native"
 )
 
-var (
+var lastVideoState native.VideoState
-	lastVideoState       native.VideoState
-	videoSleepModeCtx    context.Context
-	videoSleepModeCancel context.CancelFunc
-)
-
-const (
-	defaultVideoSleepModeDuration = 1 * time.Minute
-)
 
 func triggerVideoStateUpdate() {
 	go func() {
@@ -29,92 +17,3 @@ 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,34 +39,6 @@ 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()
@@ -340,8 +312,9 @@ func newSession(config SessionConfig) (*Session, error) {
 		if connectionState == webrtc.ICEConnectionStateConnected {
 			if !isConnected {
 				isConnected = true
+				actionSessions++
 				onActiveSessionsChanged()
-				if incrActiveSessions() == 1 {
+				if actionSessions == 1 {
 					onFirstSessionConnected()
 				}
 			}
@@ -380,8 +353,9 @@ func newSession(config SessionConfig) (*Session, error) {
 			}
 			if isConnected {
 				isConnected = false
+				actionSessions--
 				onActiveSessionsChanged()
-				if decrActiveSessions() == 0 {
+				if actionSessions == 0 {
 					onLastSessionDisconnected()
 				}
 			}
@@ -390,16 +364,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()
 }