objc.io

00:06 This is the 200th episode of Swift Talk! When we first started the project, we weren't counting on being able to do this for so long, but we're still having a lot of fun. We're so grateful to our subscribers and to everyone who watches for making it all possible.

00:57 We've done a few Q&A episodes for past milestones, but we'll be doing a regular episode today, in which we'll continue working on our Recordings app.

Observable Recorder

01:16 We're at the point where we've transferred almost all functionality over from the MVC version of the app, and we've done so by changing as little of the model code as we could.

01:43 Today, we want to again look at the Recorder class: our AVAudioRecorder wrapper, which gets configured with an update function. Whenever anything changes in the recorder, it calls the update function with a TimeInterval?. This value is either not nil, in which case the time interval refers to the number of seconds recorded, or nil, which means some error has occurred.

02:18 We currently use the update function to assign the received time interval to a state variable, which triggers the UI to update. This is basically the simplest way to convert calls to the callback into state changes:

struct RecordingView: View {
    // ...
    @State private var time: TimeInterval = 0
    // ...

    var body: some View {
        VStack(spacing: 20) {
            // ...
        }
        .onAppear {
            guard let s = self.folder.store, let url = s.fileURL(for: self.recording) else { return }
            self.recorder = Recorder(url: url) { time in
                self.time = time ?? 0
            }
        }
        // ...
    }
}

02:58 We now want to get rid of the update function and turn Recorder into an ObservableObject. So we remove the update function from the class's properties and from its initializer.

03:47 Instead of emitting changes through a callback, we want to publish the recorder's current time. And to report about error cases, we add a second published property that holds an optional error:

enum RecorderError: Error, Equatable {
    case noPermission
    case other
}

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    @Published var currentTime: TimeInterval = 0
    @Published var error: RecorderError? = nil
    // ...
}	

05:23 In the recorder's initializer, we set an error if we don't have permission to record audio:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    private var audioRecorder: AVAudioRecorder?
    private var timer: Timer?
    let url: URL
    
    @Published var currentTime: TimeInterval = 0
    @Published var error: RecorderError? = nil
    
    init?(url: URL) {
        self.url = url
        
        super.init()
        
        do {
            try AVAudioSession.sharedInstance().setCategory(AVAudioSession.Category.playAndRecord)
            try AVAudioSession.sharedInstance().setActive(true)
            AVAudioSession.sharedInstance().requestRecordPermission() { allowed in
                if allowed {
                    self.start(url)
                } else {
                    self.error = .noPermission
                }
            }
        } catch {
            return nil
        }
    }
    // ...
}

05:35 While we're recording, we use a timer to periodically check the AVAudioRecorder's state. In the timer's block, we can update currentTime with the recorder's time:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    private func start(_ url: URL) {
        let settings: [String: Any] = [
            AVFormatIDKey: kAudioFormatMPEG4AAC,
            AVSampleRateKey: 44100.0 as Float,
            AVNumberOfChannelsKey: 1
        ]
        if let recorder = try? AVAudioRecorder(url: url, settings: settings) {
            recorder.delegate = self
            audioRecorder = recorder
            recorder.record()
            timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [unowned self] _ in
                self.currentTime = recorder.currentTime
            }
        } else {
            update(nil)
        }
    }
    // ...
}

We've marked self as unowned in the timer's block above in order to not create a reference cycle.

06:39 Then, in the cases where the AVAudioRecorder can't be created or where the recorder flags anything going wrong, we propagate an .other error:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    private func start(_ url: URL) {
        let settings: [String: Any] = [
            AVFormatIDKey: kAudioFormatMPEG4AAC,
            AVSampleRateKey: 44100.0 as Float,
            AVNumberOfChannelsKey: 1
        ]
        if let recorder = try? AVAudioRecorder(url: url, settings: settings) {
            recorder.delegate = self
            audioRecorder = recorder
            recorder.record()
            timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [unowned self] _ in
                self.currentTime = recorder.currentTime
            }
        } else {
            self.error = .other
        }
    }

    // ...

    func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool) {
        if flag {
            stop()
        } else {
            self.error = .other
        }
    }
}

Lazy Recorder

07:15 Now we can update the recorder view, which uses the Recorder class. First, we use last week's Lazy wrapper to change the optional Recorder value into an observed Lazy<Recorder>:

struct RecordingView: View {
    // ...
    @ObservedObject private var recorder: Lazy<Recorder>
    // ...
}

08:39 Instead of creating the recorder in didAppear, we do so in a custom initializer of the view:

struct RecordingView: View {
    let folder: Folder
    @Binding var isPresented: Bool
    
    private let recording = Recording(name: "", uuid: UUID())
    @ObservedObject private var recorder: Lazy<Recorder>
    @State private var isSaving: Bool = false
    @State private var deleteOnCancel = true
    @State private var time: TimeInterval = 0
    
    init?(folder: Folder, isPresented: Binding<Bool>) {
        self.folder = folder
        self._isPresented = isPresented
        guard let s = self.folder.store, let url = s.fileURL(for: self.recording) else { return nil }
        self.recorder = Lazy { Recorder(url: url) }
    }

09:53 Now that we can report any errors through the published property, Recorder's initializer no longer needs to be failable:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    init(url: URL) {
        self.url = url
        
        super.init()
        
        do {
            try AVAudioSession.sharedInstance().setCategory(AVAudioSession.Category.playAndRecord)
            try AVAudioSession.sharedInstance().setActive(true)
        } catch {
            self.error = .other
            return
        }
        AVAudioSession.sharedInstance().requestRecordPermission() { allowed in
            if allowed {
                self.start(url)
            } else {
                self.error = .noPermission
            }
        }
    }
    // ...
}

10:55 Back in the view, we use the recorder's currentTime property, which we can access directly because the Lazy wrapper implements dynamic member lookup:

struct RecordingView: View {
    // ...
    @ObservedObject private var recorder: Lazy<Recorder>
    // ...

    var body: some View {
        VStack(spacing: 20) {
            Text("Recording")
            Text(timeString(recorder.currentTime))
                .font(.title)
            Button("Stop") {
                self.recorder.value.stop()
                self.isSaving = true
            }
            .buttonStyle(PrimaryButtonStyle())
        }
        // ...
    }
}

11:31 We try running the app and creating a new recording, and it works.

Testing the Permission Flow

11:50 We also want to test the scenario where we don't have recording permission, so we add some simple error messages to the view:

struct RecordingView: View {
    // ...
    @ObservedObject private var recorder: Lazy<Recorder>
    // ...

    var body: some View {
        VStack(spacing: 20) {
            if recorder.error == .noPermission {
                Text("Go to Settings.")
            } else if recorder.error != nil {
                Text("An error occurred.")
            } else {
                Text("Recording")
                Text(timeString(recorder.currentTime))
                    .font(.title)
                Button("Stop") {
                    self.recorder.value.stop()
                    self.isSaving = true
                }
                .buttonStyle(PrimaryButtonStyle())
            }
        }
        // ...
    }
}

13:00 If we don't give the app permission to record audio, the "Go to Settings" message appears. And if we remove and reinstall the app and then grant the permission, the recording view starts recording, but the time label doesn't update.

14:04 If we stop recording and immediately go back into the recording view, the label does update. So, something must be wrong in the way we handle the permission request.

14:32 In the call to the session's requestRecordPermission method, we use a callback to either start the recording or show the no-permission error:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    init(url: URL) {
        // ...
        AVAudioSession.sharedInstance().requestRecordPermission() { allowed in
            if allowed {
                self.start(url)
            } else {
                self.error = .noPermission
            }
        }
    }
    // ...
}

Looking at the documentation, we get an idea about what might be going on: we learn that the permission request's callback may be called on a different thread. By dispatching our work onto the main queue, the UI updates are performed correctly:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    init(url: URL) {
        // ...
        AVAudioSession.sharedInstance().requestRecordPermission() { allowed in
            DispatchQueue.main.async {
                if allowed {
                    self.start(url)
                } else {
                    self.error = .noPermission
                }
            }
        }
    }
    // ...
}

Dismissing the Recording Sheet

15:46 Next, we want to tackle a to-do that we still have in our code. The recording view gets presented in a sheet, which can be dismissed by swiping it down. If this happens, we still have to stop the recorder, and since we won't be saving the recording to a folder, we have to delete the recording's audio file.

16:51 We add a cancel method that does these things, and we call it in onDisappear:

struct RecordingView: View {
    // ...
    
    func cancel() {
        recorder.value.stop()
        recording.deleted()
    }
    
    var body: some View {
        VStack(spacing: 20) {
            // ...
        }
        .padding()
        .onDisappear {
            self.cancel()
        }
        .textAlert(isPresented: $isSaving, title: "Save Recording", placeholder: "Name", callback: { self.save(name: $0) })
    }
}

17:23 We set a breakpoint in the onDisappear block, but when we dismiss the sheet, we don't hit this breakpoint. Instead, the app crashes in the recorder's timer callback. But we expect the timer to have been invalidated by the stop method, which gets called when the recorder view disappears:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    private var timer: Timer?
    // ...
    
    private func start(_ url: URL) {
        // ...
        if let recorder = try? AVAudioRecorder(url: url, settings: settings) {
            recorder.delegate = self
            audioRecorder = recorder
            recorder.record()
            timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [unowned self] _ in
                self.currentTime = recorder.currentTime
            }
        } else {
            self.error = .other
        }
    }
    
    func stop() {
        audioRecorder?.stop()
        timer?.invalidate()
    }

    // ...
}

18:33 Something must be wrong with the sheet dismissal that keeps the recorder alive. So we take a look at RecordingView, where we see that the onDisappear call is wrapped in our text alert wrapper:

struct RecordingView: View {
    // ...
    func cancel() {
        recorder.value.stop()
        recording.deleted()
    }
    
    var body: some View {
        VStack(spacing: 20) {
            // ...
        }
        .padding()
        .onDisappear {
            self.cancel()
        }
        .textAlert(isPresented: $isSaving, title: "Save Recording", placeholder: "Name", callback: { self.save(name: $0) })
    }
}

19:21 The onDisappear block never gets called because it's wrapped in a UIHostingController. When we turn this around, we hit the breakpoint after we swipe down on the recording sheet:

struct RecordingView: View {
    // ...
    func cancel() {
        recorder.value.stop()
        recording.deleted()
    }
    
    var body: some View {
        VStack(spacing: 20) {
            // ...
        }
        .padding()
        .textAlert(isPresented: $isSaving, title: "Save Recording", placeholder: "Name", callback: { self.save(name: $0) })
        .onDisappear {
            self.cancel()
        }
    }
}

19:49 But now we hit this breakpoint regardless of whether we dismiss the sheet by dragging down or by saving the recording. This turns out to be a problem when we first save a recording and then reopen that same recording: the player now crashes because the recording's audio file was deleted when the recording view disappeared.

20:57 We should only delete the file if the recording hasn't been saved. So we create a state variable that can be checked to see if the file should be deleted:

struct RecordingView: View {
    // ...
    @State private var deleteOnCancel = true
    // ...

    func save(name: String?) {
        if let n = name {
            recording.setName(n)
            folder.add(recording)
            self.deleteOnCancel = false
        }
        isPresented = false
    }
    
    func cancel() {
        recorder.value.stop()
        guard self.deleteOnCancel else { return }
        recording.deleted()
    }
    // ...
}

22:08 And that fixes the crash.

Fixing a Memory Issue

22:31 The onDisappear dance can be circumvented by moving some logic into the model layer: we can leverage the lifecycle of the Recorder class and do the cleanup work in its deinit.

22:48 But we'll find a problem when we start implementing this. Let's print a line to the console in the recorder's deinit:

final class Recorder: NSObject, AVAudioRecorderDelegate, ObservableObject {
    // ...
    deinit {
        print("Recorder deinit")
    }
}

23:05 If we dismiss the recording view by swiping down, the debug message gets printed. But it doesn't print if we dismiss the recording view by pressing the stop button and then the cancel button of the name alert. When we take a look at the memory graph, we see that the Recorder is being kept alive by a closure that's referenced by a UIAlertController. But this controller really shouldn't be around after we dismiss the alert.

24:56 In our code, we see that the alert is strongly referenced in the second action's closure. We solve the issue by making it an unowned reference:

func modalTextAlert(title: String, accept: String = .ok, cancel: String = .cancel, placeholder: String, callback: @escaping (String?) -> ()) -> UIAlertController {
    let alert = UIAlertController(title: title, message: nil, preferredStyle: .alert)
    alert.addTextField { $0.placeholder = placeholder }
    alert.addAction(UIAlertAction(title: cancel, style: .cancel) { _ in
        callback(nil)
    })
    alert.addAction(UIAlertAction(title: accept, style: .default) { [unowned alert] _ in
        callback(alert.textFields?.first?.text)
    })
    return alert
}

26:09 We could achieve the same effect by passing a reference to the alert's text field — instead of the alert itself — into the closure:

func modalTextAlert(title: String, accept: String = .ok, cancel: String = .cancel, placeholder: String, callback: @escaping (String?) -> ()) -> UIAlertController {
    let alert = UIAlertController(title: title, message: nil, preferredStyle: .alert)
    alert.addTextField { $0.placeholder = placeholder }
    alert.addAction(UIAlertAction(title: cancel, style: .cancel) { _ in
        callback(nil)
    })
    let tf = alert.textFields?.first
    alert.addAction(UIAlertAction(title: accept, style: .default) { _ in
        callback(tf?.text)
    })
    return alert
}

26:26 Another way is to move the text field variable declaration inside the closure. This makes it very explicit that the closure captures only the text field:

alert.addAction(UIAlertAction(title: accept, style: .default) { [tf = alert.textFields?.first] _ in
    callback(tf?.text)
})

More to Come

27:28 It's nice that Recorder is now used as an observed object and that we don't need to have an extra state variable as a bridge between the old callback API and SwiftUI. This way, the Recorder model fits in much better.

27:50 We've thought of also making the Player class into an observable object, but we decided against it. Player is really just a wrapper around AVAudioPlayer, and it wouldn't make much sense to mirror the properties and subscribe to the events we need. Our current implementation of calling objectWillChange.send in a few places is much simpler.

28:15 However, the rest of the model layer — the Store, Recording, and Folder classes — can still be improved to be a better fit for SwiftUI.