SwiftUI VideoPlayer leaking (@State management issue)

Question

I’m trying to create a looping video player view. Based on Apple’s docs, I did this:

struct
VideoPlayerView: View
{
    let video           :   Video
    let isPlaying       :   Bool
    
    
    init(video: Video, isPlaying: Bool)
    {
        Self.logger.info("VideoPlayerView.init: \(video.name)")
        
        self.video = video
        self.isPlaying = isPlaying
        
        if let url = self.video.url
        {
            let playerItem = AVPlayerItem(url: url)
            self._player = State(initialValue: AVQueuePlayer(playerItem: playerItem))
            self._looper = State(initialValue: AVPlayerLooper(player: self.player!, templateItem: playerItem))
        }
    }
    
    var
    body: some View
    {
        let _ = print("VideoPlayerView body requested: “\(self.video.name)” [\(self.namespace)]", terminator: " -- ")
        let _ = Self._printChanges()
        
        VStack
        {
            if let player = self.player
            {
                VideoPlayer(player: player)
            }
            else
            {
                Text("Unable to create player.")
            }
        }
        .onAppear()
        {
            Self.logger.info("Player appeared: \(self.video.name)")
            self.isPlaying ? self.player?.play() : self.player?.pause()
        }
        .onDisappear()
        {
            Self.logger.info("Player disappeared: \(self.video.name)")
            self.player?.pause()
            self.player?.seek(to: .zero)
        }
        .onChange(of: self.isPlaying)
        { inOld, inNew in
            Self.logger.info("isPlaying changed: \(inNew)")
            inNew ? self.player?.play() : self.player?.pause()
        }
    }
    
    @State  private var player          :   AVQueuePlayer?
    @State  private var looper          :   AVPlayerLooper?
    
    @Namespace private var namespace
    
    static  let logger          =   Logger(subsystem: "<>", category: "VideoPlayerView")
}

I instantiate it as part of a NavigationSplitView detail, based on the current selection:

        detail:
        {
            let sortedSelection = self.selection.sorted(using: SortDescriptor(\.lastViewed))
            if sortedSelection.count > 0
            {
                ScrollView
                {
                    VStack
                    {
                        ForEach(sortedSelection)
                        { video in
                            VideoPlayerView(video: video, isPlaying: self.isPlaying)
                                .id(video)
                                .aspectRatio(4.0/3.0, contentMode: .fit)
                        }
                    }
                }
            }
            else
            {
                Text("Select an Item")
            }
        }

@Model
final
class
Video
{
    var name            :   String
    var bookmark        :   Data
    var lastViewed      :   Date?
    
    var
    url: URL?
    {
        <get url from bookmark>
    }

There are problems with this approach:

• If a video is playing when another is selected, the first video’s view disappears, but you can hear the audio continue to play (until I called pause() in .onDisappear(), anyway).
• Every time something changes, like whether or not videos are playing, this code creates a new suite of AVFoundation objects. I don’t actually know what @State does in this situation. Does it just discard the new initial value, since state already exists for this view?
• Looking at memory consumption and thread creation, the answer to this is no. Every time I stop and start a video playing, memory goes up, and a few new threads are created.

I can’t think of a better way to manage this player state. Assigning state in .onAppear() and set it to nil in .onDisppear() doesn’t change the behavior; memory still grows and threads continue to be created.

Answer 1

Unfortunately apple's sample code has major flaws, as is usual when other framework teams attempt SwiftUI.

@State can't be used with a class like AVPlayer that's a memory leak in itself. The initial state is recreated every time the View is init, no big deal for a value type in the memory stack but should be avoided for an object in the memory heap. StateObject avoids this by only initing the object once (via @autoclosure) and you can put your player object inside that. It will auto init on appear and de-init on disappear and as long as your player doesn't have any retain cycles it will be deinit too.

State for isPlaying violates SwiftUIs single source of truth design because it is trying to copy the state into the player instead of using the player as the source of truth for playing. Eg when a video ends the internal state is stopped but a state Boolean would still be playing true which is an inconsistency that SwiftUIs single source design attempts to eliminate.

You'll need to remove your custom View inits you shouldn't need those. Also onAppear is designed for external actions not for updating state so remove those too. You'll need a state object with a publisher for the players playing state either using notifications, delegate or last resort a KVO publisher.