Properly handle broadcast capture state

Sources/LiveKit/Broadcast/BroadcastExtensionState.swift

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if os(iOS)
+
+import Combine
+import Foundation
+
+#if canImport(ReplayKit)
+import ReplayKit
+#endif
+
+class BroadcastExtensionState {
+    /// A publisher that emits a Boolean value indicating whether or not the extension is currently broadcasting.
+    static var isBroadcasting: some Publisher<Bool, Never> {
+        Publishers.Merge(
+            DarwinNotificationCenter.shared.publisher(for: .broadcastStarted).map { _ in true },
+            DarwinNotificationCenter.shared.publisher(for: .broadcastStopped).map { _ in false }
+        )
+        .eraseToAnyPublisher()
+    }
+
+    /// Displays the system broadcast picker, allowing the user to start the broadcast.
+    /// - Note: This is merely a request and does not guarantee the user will choose to start the broadcast.
+    static func requestActivation() async {
+        await RPSystemBroadcastPickerView.show(
+            for: BroadcastScreenCapturer.screenSharingExtension,
+            showsMicrophoneButton: false
+        )
+    }
+}
+
+#endif

Sources/LiveKit/Broadcast/Uploader/DarwinNotificationCenter.swift

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import Combine
 import Foundation
 
 enum DarwinNotification: String {
@@ -23,7 +24,6 @@ enum DarwinNotification: String {
 
 final class DarwinNotificationCenter: @unchecked Sendable {
     public static let shared = DarwinNotificationCenter()
-
     private let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
 
     func postNotification(_ name: DarwinNotification) {
@@ -34,3 +34,99 @@ final class DarwinNotificationCenter: @unchecked Sendable {
                                              true)
     }
 }
+
+extension DarwinNotificationCenter {
+    /// Returns a publisher that emits events when broadcasting notifications matching the given name.
+    func publisher(for name: DarwinNotification) -> Publisher {
+        Publisher(notificationCenter, name)
+    }
+
+    /// A publisher that emits notifications.
+    struct Publisher: Combine.Publisher {
+        typealias Output = DarwinNotification
+        typealias Failure = Never
+
+        private let name: DarwinNotification
+        private let center: CFNotificationCenter?
+
+        fileprivate init(_ center: CFNotificationCenter?, _ name: DarwinNotification) {
+            self.name = name
+            self.center = center
+        }
+
+        func receive<S>(
+            subscriber: S
+        ) where S: Subscriber, Never == S.Failure, DarwinNotification == S.Input {
+            subscriber.receive(subscription: Subscription(subscriber, center, name))
+        }
+    }
+
+    private class SubscriptionBase {
+        let name: DarwinNotification
+        let center: CFNotificationCenter?
+
+        init(_ center: CFNotificationCenter?, _ name: DarwinNotification) {
+            self.name = name
+            self.center = center
+        }
+
+        static var callback: CFNotificationCallback = { _, observer, _, _, _ in
+            guard let observer else { return }
+            Unmanaged<SubscriptionBase>
+                .fromOpaque(observer)
+                .takeUnretainedValue()
+                .notifySubscriber()
+        }
+
+        func notifySubscriber() {
+            // Overridden by generic subclass to call specific subscriber's
+            // receive method. This allows forming a C function pointer to the callback.
+        }
+    }
+
+    private class Subscription<S: Subscriber>: SubscriptionBase, Combine.Subscription where S.Input == DarwinNotification, S.Failure == Never {
+        private var subscriber: S?
+
+        init(_ subscriber: S, _ center: CFNotificationCenter?, _ name: DarwinNotification) {
+            self.subscriber = subscriber
+            super.init(center, name)
+            addObserver()
+        }
+
+        func request(_: Subscribers.Demand) {}
+
+        private var opaqueSelf: UnsafeRawPointer {
+            UnsafeRawPointer(Unmanaged.passUnretained(self).toOpaque())
+        }
+
+        private func addObserver() {
+            CFNotificationCenterAddObserver(center,
+                                            opaqueSelf,
+                                            Self.callback,
+                                            name.rawValue as CFString,
+                                            nil,
+                                            .deliverImmediately)
+        }
+
+        private func removeObserver() {
+            guard subscriber != nil else { return }
+            CFNotificationCenterRemoveObserver(center,
+                                               opaqueSelf,
+                                               CFNotificationName(name.rawValue as CFString),
+                                               nil)
+            subscriber = nil
+        }
+
+        override func notifySubscriber() {
+            _ = subscriber?.receive(name)
+        }
+
+        func cancel() {
+            removeObserver()
+        }
+
+        deinit {
+            removeObserver()
+        }
+    }
+}

Sources/LiveKit/Participant/LocalParticipant.swift

@@ -14,12 +14,9 @@
  * limitations under the License.
  */
 
+import Combine
 import Foundation
 
-#if canImport(ReplayKit)
-import ReplayKit
-#endif
-
 #if swift(>=5.9)
 internal import LiveKitWebRTC
 #else
@@ -229,6 +226,59 @@ public class LocalParticipant: Participant {
 
         return didUpdate
     }
+
+    // MARK: - Broadcast Activation
+
+    #if os(iOS)
+
+    /// An optional hook called just after a broadcast starts.
+    ///
+    /// Returns a Boolean value indicating weather or not the broadcast should be
+    /// published as a screen share track. This could be useful to present a confirmation dialog,
+    /// returning `true` or `false` based on the user's response .
+    ///
+    public var broadcastStarted: (() async -> Bool)?
+
+    private var isBroadcasting = false {
+        didSet { broadcastStateChanged() }
+    }
+
+    private var cancellable = Set<AnyCancellable>()
+
+    override init(room: Room, sid: Participant.Sid? = nil, identity: Participant.Identity? = nil) {
+        super.init(room: room, sid: sid, identity: identity)
+
+        BroadcastExtensionState
+            .isBroadcasting
+            .sink { [weak self] in
+                guard let self else { return }
+                self.isBroadcasting = $0
+            }
+            .store(in: &cancellable)
+    }
+
+    private func broadcastStateChanged() {
+        guard isBroadcasting else {
+            logger.debug("Broadcast stopped")
+            return
+        }
+        logger.debug("Broadcast started")
+
+        Task { [weak self] in
+            guard let self else { return }
+            let shouldPublish = await self.broadcastStarted?() ?? true
+            guard shouldPublish else {
+                logger.debug("Will not publish screen share track")
+                return
+            }
+            do {
+                try await self.setScreenShare(enabled: true)
+            } catch {
+                logger.error("Failed to enable screen share: \(error)")
+            }
+        }
+    }
+    #endif
 }
 
 // MARK: - Session Migration
@@ -339,10 +389,11 @@ public extension LocalParticipant {
                     let localTrack: LocalVideoTrack
                     let options = (captureOptions as? ScreenShareCaptureOptions) ?? room._state.roomOptions.defaultScreenShareCaptureOptions
                     if options.useBroadcastExtension {
-                        await RPSystemBroadcastPickerView.show(
-                            for: BroadcastScreenCapturer.screenSharingExtension,
-                            showsMicrophoneButton: false
-                        )
+                        guard self.isBroadcasting else {
+                            await BroadcastExtensionState.requestActivation()
+                            return nil
+                        }
+                        // Wait until broadcasting to publish track
                         localTrack = LocalVideoTrack.createBroadcastScreenCapturerTrack(options: options)
                     } else {
                         localTrack = LocalVideoTrack.createInAppScreenShareTrack(options: options)

Tests/LiveKitTests/DarwinNotificationCenterTests.swift

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Combine
+@testable import LiveKit
+import XCTest
+
+class DarwinNotificationCenterTests: XCTestCase {
+    func testPublisher() throws {
+        let receiveFirst = XCTestExpectation(description: "Receive from 1st subscriber")
+        let receiveSecond = XCTestExpectation(description: "Receive from 2nd subscriber")
+
+        let name = DarwinNotification.broadcastStarted
+
+        var cancellable = Set<AnyCancellable>()
+        DarwinNotificationCenter.shared
+            .publisher(for: name)
+            .sink {
+                XCTAssertEqual($0, name)
+                receiveFirst.fulfill()
+            }
+            .store(in: &cancellable)
+        DarwinNotificationCenter.shared
+            .publisher(for: name)
+            .sink {
+                XCTAssertEqual($0, name)
+                receiveSecond.fulfill()
+            }
+            .store(in: &cancellable)
+
+        DarwinNotificationCenter.shared.postNotification(name)
+        wait(for: [receiveFirst, receiveSecond], timeout: 10.0)
+    }
+}