Add higher-level finishCallback closure

Sources/PlaydateKit/Core/Sound.swift

@@ -1,4 +1,4 @@
 public import CPlaydate
 
 /// Functions related to audio playback.
 ///
@@ -6,22 +6,28 @@
 /// longer files (uncompressed, MP3, and ADPCM formats), and a synthesis library for generating "computer-y" sounds.
 /// Sound sources are grouped into channels, which can be panned separately, and various effects may be applied to the channels.
 /// Additionally, signals can automate various parameters of the sound objects..
 public enum Sound {
     // MARK: Public
 
     /// The fileplayer class is used for streaming audio from a file on disk. This requires less memory than keeping all of the
     /// file’s data in memory (as with the sampleplayer), but can increase overhead at run time.
     public class FilePlayer {
         // MARK: Lifecycle
 
         /// Creates a new FilePlayer.
         public init() {
             pointer = fileplayer.newPlayer.unsafelyUnwrapped().unsafelyUnwrapped
         }
 
-        deinit { fileplayer.freePlayer.unsafelyUnwrapped(pointer) }
+        deinit {
+            fileplayer.freePlayer.unsafelyUnwrapped(pointer)
+            if let callbackData = _callbackData {
+                callbackData.deinitialize(count: 1)
+                callbackData.deallocate()
+            }
+        }
 
         // MARK: Public
 
         /// Returns true if player is playing
         public var isPlaying: Bool {
@@ -30,12 +36,12 @@
 
         /// Prepares player to stream the file at path. Returns `true` if the file exists, otherwise `false`.
         @discardableResult public func load(path: StaticString) -> Bool {
-            fileplayer.loadIntoPlayer(pointer, path.utf8Start) == 0
+            fileplayer.loadIntoPlayer(pointer, path.utf8Start) == 1
         }
 
         /// Prepares player to stream the file at path. Returns `true` if the file exists, otherwise `false`.
         @discardableResult public func load(path: UnsafePointer<CChar>) -> Bool {
-            fileplayer.loadIntoPlayer(pointer, path) == 0
+            fileplayer.loadIntoPlayer(pointer, path) == 1
         }
 
         /// Starts playing the file player. If repeat is greater than one, it loops the given number of times.
@@ -43,10 +49,41 @@
         /// Returns 1 on success, 0 if buffer allocation failed.
         @discardableResult public func play(repeat: Int32 = 1) -> Int32 {
             fileplayer.play.unsafelyUnwrapped(pointer, `repeat`)
         }
+
+        // `CallbackData` wraps the callback closure and is stored in a dynamically allocated block, which
+        // is passed as `userData` to `setFinishCallback` below.
+        private struct CallbackData {
+            var callback: (() -> Void)?
+        }
+        private var _callbackData: UnsafeMutablePointer<CallbackData>?
+
+        /// Installs a closure that will be called when playback has completed.
+        public var finishCallback: (() -> Void)? {
+            get {
+                _callbackData?.pointee.callback
+            }
+            set {
+                if let callbackData = _callbackData {
+                    callbackData.pointee.callback = newValue
+                } else if let newValue {
+                    let callbackData: UnsafeMutablePointer<CallbackData> = .allocate(capacity: 1)
+                    callbackData.initialize(to: .init(callback: newValue))
+                    _callbackData = callbackData
+                    setFinishCallback(
+                        callback: { sourceSource, userdata in
+                            if let callback = userdata?.assumingMemoryBound(to: CallbackData.self).pointee.callback {
+                                callback()
+                            }
+                        },
+                        soundUserdata: callbackData
+                    )
+                }
+            }
+        }
 
         /// Sets a function to be called when playback has completed.
-        public func setFinishCallback(
+        func setFinishCallback(
             callback: @convention(c) (
                 _ soundSource: OpaquePointer?,
                 _ userdata: UnsafeMutableRawPointer?