Callback or Signal for Playback complete

[JackMordaunt]

Instead of polling the player, perhaps it would be better to offer either a callback or a channel style API.

    // We can wait for the sound to finish playing using something like this
    for player.IsPlaying() {
        time.Sleep(time.Millisecond)
    }

// Channel style.
<-player.Done()

// Callback style.
player.OnDone(func() {...})

[JackMordaunt]

You can get underneath the player with a custom io.Reader, but it is a bit annoying - but maybe a good route?

// TriggerReader invokes a callback when EOF is reached.
type TriggerReader struct {
	r  io.Reader
	cb func()
}

func (t *TriggerReader) Read(p []byte) (n int, err error) {
	n, err = t.r.Read(p)
	if err == io.EOF {
		t.Callback()
	}
	return n, err
}

func (t *TriggerReader) Callback() {
	if t.cb != nil {
		t.cb()
	}
}

done := make(chan struct{})
data := []byte{...}
src := bytes.NewReader(data)
src = &TriggerReader{r: src, cb: func() {close(done)}}
p := ctx.NewPlayer(src)
p.Play()
<-done

[hajimehoshi]

I was wondering why you need to detect the timing when the player ends in the first place.

[JackMordaunt]

I have a program that wants to exit once playback is finished, but you could also imagine advancing a track in a playlist, or similar.

[MarkKremer]

Another use case could be that we want to wait for the player to finish and all the samples be sent to the driver before suspending so that the last couple of samples don't get lost.

I was discussing this regarding Beep from this comment down: gopxl/beep#137 (comment)

[vsariola]

I agree, the polling smells badly. My recommended solution is to use a channel, but so that nothing ever gets sent through this channel, it is only closed. So, for example, player.Finished() returns a <-chan struct{}, and anyone interested in knowing when the player is finished can do:

<-player.Finished()

However, the reason for player to close the channel instead of sending struct{} value through it is that if multiple listeners are waiting, only one of them would wake up. Close signals immediately to all listeners, and any future attempts to wait for a closed channel return immediately. This also allows the user to add a timeout using golang native syntax e.g.:

select {
  case <-player.Finished():
     ...
  case <-time.After(3 * time.Second):
    ....
}

Instead of using channels, making player.Finished() return a sync.WaitGroup might be work, with 1 counter. Or have Player just method Wait() , calling the Wait() method its internal sync.WaitGroup. But this does not allow defining a timeout.