Implement more efficient run loop

internal/animation/animation_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/test"
 )
 
 func tick(run *Runner) {
@@ -18,6 +19,7 @@ func tick(run *Runner) {
 }
 
 func TestGLDriver_StartAnimation(t *testing.T) {
+	test.NewTempApp(t)
 	done := make(chan float32)
 	run := &Runner{}
 	a := &fyne.Animation{
@@ -37,6 +39,7 @@ func TestGLDriver_StartAnimation(t *testing.T) {
 }
 
 func TestGLDriver_StopAnimation(t *testing.T) {
+	test.NewTempApp(t)
 	done := make(chan float32)
 	run := &Runner{}
 	a := &fyne.Animation{
@@ -54,12 +57,13 @@ func TestGLDriver_StopAnimation(t *testing.T) {
 		t.Error("animation was not ticked")
 	}
 	run.Stop(a)
-	run.animationMutex.RLock()
+	run.animationMutex.Lock()
 	assert.Zero(t, len(run.animations))
-	run.animationMutex.RUnlock()
+	run.animationMutex.Unlock()
 }
 
 func TestGLDriver_StopAnimationImmediatelyAndInsideTick(t *testing.T) {
+	test.NewTempApp(t)
 	var wg sync.WaitGroup
 	run := &Runner{}
 
@@ -107,7 +111,7 @@ func TestGLDriver_StopAnimationImmediatelyAndInsideTick(t *testing.T) {
 	wg.Wait()
 	// animations stopped inside tick are really stopped in the next runner cycle
 	time.Sleep(time.Second/60 + 100*time.Millisecond)
-	run.animationMutex.RLock()
+	run.animationMutex.Lock()
 	assert.Zero(t, len(run.animations))
-	run.animationMutex.RUnlock()
+	run.animationMutex.Unlock()
 }

internal/animation/runner.go

@@ -11,7 +11,7 @@ import (
 type Runner struct {
 	// animationMutex synchronizes access to `animations` and `pendingAnimations`
 	// between the runner goroutine and calls to Start and Stop
-	animationMutex sync.RWMutex
+	animationMutex sync.Mutex
 
 	// animations is the list of animations that are being ticked in the current frame
 	animations []*anim
@@ -33,7 +33,7 @@ type Runner struct {
 // Start will register the passed application and initiate its ticking.
 func (r *Runner) Start(a *fyne.Animation) {
 	r.animationMutex.Lock()
-	defer r.animationMutex.Unlock()
+	hadAnimations := len(r.pendingAnimations) > 0 || len(r.animations) > 0
 
 	if !r.runnerStarted {
 		r.runnerStarted = true
@@ -51,6 +51,21 @@ func (r *Runner) Start(a *fyne.Animation) {
 		}
 		r.pendingAnimations = append(r.pendingAnimations, newAnim(a))
 	}
+	r.animationMutex.Unlock()
+
+	if !hadAnimations {
+		// wake up main thread if needed to begin running animations
+		if drv, ok := fyne.CurrentApp().Driver().(interface{ WakeUp() }); ok {
+			drv.WakeUp()
+		}
+	}
+}
+
+func (r *Runner) HasAnimations() bool {
+	r.animationMutex.Lock()
+	defer r.animationMutex.Unlock()
+
+	return len(r.pendingAnimations) > 0 || len(r.animations) > 0
 }
 
 // Stop causes an animation to stop ticking (if it was still running) and removes it from the runner.
@@ -86,18 +101,19 @@ func (r *Runner) Stop(a *fyne.Animation) {
 
 // TickAnimations progresses all running animations by one tick.
 // This will be called from the driver to update objects immediately before next paint.
-func (r *Runner) TickAnimations() {
+func (r *Runner) TickAnimations() (done bool) {
 	if !r.runnerStarted {
-		return
+		return true
 	}
 
-	done := r.runOneFrame()
+	done = r.runOneFrame()
 
 	if done {
 		r.animationMutex.Lock()
 		r.runnerStarted = false
 		r.animationMutex.Unlock()
 	}
+	return done
 }
 
 func (r *Runner) runOneFrame() (done bool) {

internal/driver/common/canvas.go

@@ -349,6 +349,13 @@ func (c *Canvas) CheckDirtyAndClear() bool {
 // SetDirty sets canvas dirty flag atomically.
 func (c *Canvas) SetDirty() {
 	c.dirty = true
+
+	// wake up main thread in case we were called from goroutine
+	// TODO: hide this behind the migration flag introduced in
+	// https://github.com/fyne-io/fyne/pull/5425
+	if drv, ok := fyne.CurrentApp().Driver().(interface{ WakeUp() }); ok {
+		drv.WakeUp()
+	}
 }
 
 // SetMenuTreeAndFocusMgr sets menu tree and focus manager.

internal/driver/common/ringbuffer.go

@@ -0,0 +1,81 @@
+package common
+
+// RingBuffer is a growable ring buffer supporting
+// enqueue and dequeue operations. It is not thread safe.
+type RingBuffer[T any] struct {
+	buf  []T
+	head int
+	len  int
+}
+
+// NewRingBuffer initializes and returns a new RingBuffer.
+func NewRingBuffer[T any](initialCap int) RingBuffer[T] {
+	return RingBuffer[T]{
+		buf: make([]T, initialCap),
+	}
+}
+
+// Len returns the number of elements in the buffer.
+func (r *RingBuffer[T]) Len() int {
+	return r.len
+}
+
+// Push adds the value to the end of the buffer.
+func (r *RingBuffer[T]) Push(value T) {
+	r.checkGrow()
+
+	pos := (r.head + r.len) % len(r.buf)
+	r.buf[pos] = value
+	r.len++
+}
+
+// Pull removes the first item from the buffer, if any.
+func (r *RingBuffer[T]) Pull() (value T, ok bool) {
+	if r.len == 0 {
+		return value, false
+	}
+	return r.pullOne(), true
+}
+
+// PullN removes up to len(buf) items from the queue,
+// copying them into the supplied buffer and returning
+// the number of elements copied.
+func (r *RingBuffer[T]) PullN(buf []T) int {
+	l := len(buf)
+	if r.len < l {
+		l = r.len
+	}
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		buf[i] = r.pullOne()
+	}
+	return l
+}
+
+func (r *RingBuffer[T]) pullOne() (value T) {
+	emptyT := value
+	value = r.buf[r.head]
+	r.buf[r.head] = emptyT
+
+	if r.len == 1 {
+		r.head = 0
+	} else {
+		r.head = (r.head + 1) % len(r.buf)
+	}
+	r.len--
+
+	return value
+}
+
+func (r *RingBuffer[T]) checkGrow() {
+	if l := len(r.buf); r.len == l {
+		newBuf := make([]T, l*2)
+		for i := 0; i < r.len; i++ {
+			newBuf[i] = r.buf[(r.head+i)%l]
+		}
+		r.head = 0
+		r.buf = newBuf
+	}
+}

internal/driver/common/ringbuffer_test.go

@@ -0,0 +1,46 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_RingBuffer(t *testing.T) {
+	buf := NewRingBuffer[int](8)
+
+	assertDequeue := func(expect int) {
+		t.Helper()
+		got, valid := buf.Pull()
+		assert.True(t, valid, "got invalid pull")
+		assert.Equal(t, expect, got, "invalid pull result")
+	}
+
+	buf.Push(1)
+	buf.Push(2)
+	buf.Push(3)
+	buf.Push(4)
+	buf.Push(5)
+	buf.Push(6)
+	buf.Push(7)
+	buf.Push(8)
+	buf.Push(9)
+	buf.Push(10)
+
+	assertDequeue(1)
+	assertDequeue(2)
+
+	buf.Push(11)
+	buf.Push(12)
+	buf.Push(13)
+	buf.Push(14)
+	buf.Push(15)
+	buf.Push(16)
+	buf.Push(17)
+	buf.Push(18)
+	buf.Push(19)
+
+	for i := 3; i <= 19; i++ {
+		assertDequeue(i)
+	}
+}

internal/driver/glfw/driver.go

@@ -28,7 +28,6 @@ var _ fyne.Driver = (*gLDriver)(nil)
 
 type gLDriver struct {
 	windows []fyne.Window
-	done    chan struct{}
 
 	animation animation.Runner
 
@@ -101,7 +100,7 @@ func (d *gLDriver) Quit() {
 
 	// Only call close once to avoid panic.
 	if running.CompareAndSwap(true, false) {
-		close(d.done)
+		d.WakeUp()
 	}
 }
 
@@ -167,7 +166,5 @@ func (d *gLDriver) SetDisableScreenBlanking(disable bool) {
 func NewGLDriver() *gLDriver {
 	repository.Register("file", intRepo.NewFileRepository())
 
-	return &gLDriver{
-		done: make(chan struct{}),
-	}
+	return &gLDriver{}
 }