Merge pull request #1695 from HaishinKit/feature/srt-socket-options

New SRTSocketOption api.

Author: shogo4405

Examples/Examples.xcodeproj/xcuserdata/shogo.endo.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist

@@ -8,7 +8,7 @@
          BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
          <BreakpointContent
             uuid = "00193141-C09C-45D1-89AA-9219E1CB7CB6"
-            shouldBeEnabled = "Yes"
+            shouldBeEnabled = "No"
             ignoreCount = "0"
             continueAfterRunningActions = "No"
             filePath = "Examples/iOS/AppDelegate.swift"

SRTHaishinKit/Sources/SRT/SRTConnection.swift

@@ -29,52 +29,42 @@ public actor SRTConnection: NetworkConnection {
         }
     }
 
-    private var socket: SRTSocket? {
-        didSet {
-            Task {
-                guard let socket else {
-                    return
-                }
-                let networkMonitor = await socket.makeNetworkMonitor()
-                self.networkMonitor = networkMonitor
-                await networkMonitor.startRunning()
-                for await event in await networkMonitor.event {
-                    for stream in streams {
-                        await stream.dispatch(event)
-                    }
-                }
-            }
-            Task {
-                await oldValue?.stopRunning()
-            }
-        }
-    }
+    private var socket: SRTSocket?
     private var streams: [SRTStream] = []
-    private var listener: SRTSocket? {
-        didSet {
-            Task {
-                await oldValue?.stopRunning()
-            }
-        }
-    }
-    private var networkMonitor: NetworkMonitor? {
-        didSet {
-            Task {
-                await oldValue?.stopRunning()
-            }
-        }
-    }
+    private var listener: SRTSocket?
+    private var networkMonitor: NetworkMonitor?
 
     /// Creates an object.
     public init() {
         srt_startup()
+        socket = SRTSocket()
     }
 
     deinit {
         streams.removeAll()
         srt_cleanup()
     }
 
+    /// Gets a SRTSocketOption.
+    public func getSocketOption(_ name: SRTSocketOption.Name) async throws -> SRTSocketOption? {
+        try await socket?.getSocketOption(name)
+    }
+
+    /// Sets a SRTSocketOption.
+    public func setSocketOption(_ option: SRTSocketOption) async throws {
+        if connected {
+            guard option.name.restriction == .post else {
+                throw Error.invalidState
+            }
+            try await socket?.setSocketOption(option)
+        } else {
+            guard option.name.restriction == .pre else {
+                throw Error.invalidState
+            }
+            try await socket?.setSocketOption(option)
+        }
+    }
+
     /// Open a two-way connection to an application on SRT Server.
     @available(*, deprecated, renamed: "connect")
     public func open(_ uri: URL?, mode: SRTMode = .caller) async throws {
@@ -112,27 +102,40 @@ public actor SRTConnection: NetworkConnection {
         do {
             let options = SRTSocketOption.from(uri: uri)
             let addr = sockaddr_in(mode.host(host), port: UInt16(port))
-            let socket = SRTSocket()
             try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Swift.Error>) in
                 Task {
                     do {
-                        try await socket.open(addr, mode: mode, options: options)
+                        try await socket?.open(addr, mode: mode, options: options)
                         self.uri = uri
                         switch mode {
                         case .caller:
-                            self.socket = socket
+                            break
                         case .listener:
-                            self.listener = socket
-                            self.socket = try await socket.accept()
-                            self.listener = nil
+                            listener = socket
+                            socket = try await listener?.accept()
+                            await listener?.stopRunning()
+                            listener = nil
                         }
-                        connected = await self.socket?.status == .connected
+                        connected = await socket?.status == .connected
                         continuation.resume()
                     } catch {
                         continuation.resume(throwing: error)
                     }
                 }
             }
+            Task {
+                guard let socket else {
+                    return
+                }
+                let networkMonitor = await socket.makeNetworkMonitor()
+                self.networkMonitor = networkMonitor
+                await networkMonitor.startRunning()
+                for await event in await networkMonitor.event {
+                    for stream in streams {
+                        await stream.dispatch(event)
+                    }
+                }
+            }
         } catch {
             throw error
         }
@@ -143,14 +146,18 @@ public actor SRTConnection: NetworkConnection {
         guard uri != nil else {
             return
         }
+        await networkMonitor?.stopRunning()
         networkMonitor = nil
         for stream in streams {
             await stream.close()
         }
+        await socket?.stopRunning()
         socket = nil
+        await listener?.stopRunning()
         listener = nil
         uri = nil
         connected = false
+        socket = SRTSocket()
     }
 
     func send(_ data: Data) async {

SRTHaishinKit/Sources/SRT/SRTLogger.swift

@@ -29,7 +29,7 @@ public enum SRTLogLevel: Sendable {
     }
 }
 
-/// Constants that indicate the addition to levels the logging system has functional areas .
+/// Constants that indicate the addition to levels the logging system has functional areas.
 public enum SRTLogFunctionalArea: Int32, Sendable {
     /// General uncategorized log, for serious issues only
     case general = 0

SRTHaishinKit/Sources/SRT/SRTSocket.swift

@@ -83,7 +83,7 @@ final actor SRTSocket {
     private(set) var isRunning = false
     private var perf: CBytePerfMon = .init()
     private var socket: SRTSOCKET = SRT_INVALID_SOCK
-    private var options: [SRTSocketOption: any Sendable] = [:]
+    private var options: [SRTSocketOption] = []
     private var outputs: AsyncStream<Data>.Continuation? {
         didSet {
             oldValue?.finish()
@@ -96,6 +96,7 @@ final actor SRTSocket {
     private lazy var incomingBuffer: Data = .init(count: Int(windowSizeC))
 
     init() {
+        socket = srt_create_socket()
     }
 
     init(socket: SRTSOCKET) async throws {
@@ -108,12 +109,15 @@ final actor SRTSocket {
         }
     }
 
-    func open(_ addr: sockaddr_in, mode: SRTMode, options: [SRTSocketOption: any Sendable] = [:]) async throws {
-        guard socket == SRT_INVALID_SOCK else {
-            return
-        }
-        // prepare socket
-        socket = srt_create_socket()
+    func getSocketOption(_ name: SRTSocketOption.Name) throws -> SRTSocketOption {
+        return try SRTSocketOption(name: name, socket: socket)
+    }
+
+    func setSocketOption(_ option: SRTSocketOption) throws {
+        try option.setSockflag(socket)
+    }
+
+    func open(_ addr: sockaddr_in, mode: SRTMode, options: [SRTSocketOption] = []) async throws {
         if socket == SRT_INVALID_SOCK {
             throw makeSocketError()
         }
@@ -176,8 +180,8 @@ final actor SRTSocket {
         }
     }
 
-    private func configure(_ binding: SRTSocketOption.Binding) -> Bool {
-        let failures = SRTSocketOption.configure(socket, binding: binding, options: options)
+    private func configure(_ binding: SRTSocketOption.Restriction) -> Bool {
+        let failures = SRTSocketOption.configure(socket, restriction: binding, options: options)
         guard failures.isEmpty else {
             logger.error(failures)
             return false