Milestone 22 signalling 211 beta

assets/code/video-sdk/authentication-workflow/swift/fetch-token.mdx

@@ -1,86 +1,18 @@
 
-<PlatformWrapper platform="macos">
     ``` swift
-    func fetchToken() -> Bool {
-        // Construct the endpoint URL
-        channelName = channelTextField.stringValue ?? ""
-        if channelName.isEmpty {
-            showMessage(title: "Channel", text: "Please set a channel to join")
-            return false
-        }
-        guard let tokenServerURL = URL(string: "\(serverUrl)/rtc/\(channelName)/\(userRole.rawValue)/uid/\(userID)/?expiry=\(tokenExpireTime)") else {
-            return false
-        }
-        /// Semaphore waits for the request to complete, before returning the token.
-        let semaphore = DispatchSemaphore(value: 0)
-        var request = URLRequest(url: tokenServerURL, timeoutInterval: 10)
-        request.httpMethod = "GET"
+    func fetchToken(
+        from tokenUrl: String, channel: String,
+        role: AgoraClientRole, userId: UInt = 0
+    ) async throws -> String? {
+        guard !tokenUrl.isEmpty else { return nil }
 
-        // Construct the GET request
-        let task = URLSession.shared.dataTask(with: request) { data, response, err in
-            defer {
-                // Signal that the request has completed
-                semaphore.signal()
-            }
-            guard let data = data else {
-                // No data, no token
-                return
-            }
-            let responseJSON = try? JSONSerialization.jsonObject(with: data, options: [])
-            if let responseDict = responseJSON as? [String: Any], let tokenToReturn = responseDict["rtcToken"] as? String {
-                // Key "rtcToken" found in response, assigning to tokenToReturn
-                self.token = tokenToReturn
-            }
-        }
+        guard let tokenServerURL = URL(
+            string: "\(tokenUrl)/rtc/\(channel)/\(role.rawValue)/uid/\(userId)/"
+        ) else { return nil }
 
-        task.resume()
+        let (data, _) = try await URLSession.shared.data(from: tokenServerURL)
+        let tokenResponse = try JSONDecoder().decode(TokenResponse.self, from: data)
 
-        // Waiting for signal found inside the GET request handler
-        semaphore.wait()
-        return true
+        return tokenResponse.rtcToken
     }
     ```
-</PlatformWrapper>
-
-<PlatformWrapper platform="ios">
-    ``` swift
-    func fetchToken() -> Bool {
-        // Construct the endpoint URL
-        channelName = channelTextField.text ?? ""
-        if channelName.isEmpty {
-            showMessage(title: "Channel", text: "Please set a channel to join")
-            return false
-        }
-        guard let tokenServerURL = URL(string: "\(serverUrl)/rtc/\(channelName)/\(userRole.rawValue)/uid/\(userID)/?expiry=\(tokenExpireTime)") else {
-            return false
-        }
-        /// Semaphore waits for the request to complete, before returning the token.
-        let semaphore = DispatchSemaphore(value: 0)
-        var request = URLRequest(url: tokenServerURL, timeoutInterval: 10)
-        request.httpMethod = "GET"
-
-        // Construct the GET request
-        let task = URLSession.shared.dataTask(with: request) { data, response, err in
-            defer {
-                // Signal that the request has completed
-                semaphore.signal()
-            }
-            guard let data = data else {
-                // No data, no token
-                return
-            }
-            let responseJSON = try? JSONSerialization.jsonObject(with: data, options: [])
-            if let responseDict = responseJSON as? [String: Any], let tokenToReturn = responseDict["rtcToken"] as? String {
-                // Key "rtcToken" found in response, assigning to tokenToReturn
-                self.token = tokenToReturn
-            }
-        }
-
-        task.resume()
-
-        // Waiting for signal found inside the GET request handler
-        semaphore.wait()
-        return true
-    }
-    ```
-</PlatformWrapper>

assets/code/video-sdk/authentication-workflow/swift/join-channel.mdx

@@ -0,0 +1,75 @@
+
+<PlatformWrapper platform="ios">
+
+``` swift
+// This method is specifically used by the sample app. If there is a tokenURL, it will attempt to retrieve a token from there.
+internal func joinChannel(_ channel: String, uid: UInt? = nil) async -> Int32 {
+    let userId = uid ?? DocsAppConfig.shared.uid
+    var token = DocsAppConfig.shared.rtcToken
+    if !DocsAppConfig.shared.tokenUrl.isEmpty {
+        do {
+            token = try await self.fetchToken(
+                from: DocsAppConfig.shared.tokenUrl, channel: channel,
+                role: self.role, userId: userId
+            )
+        } catch {
+            print("token server fetch failed: \(error.localizedDescription)")
+        }
+    }
+    return self.joinChannel(channel, token: token, uid: userId, info: nil)
+}
+
+// Joins a channel, starting the connection to a session.
+open func joinChannel(
+    _ channel: String, token: String? = nil, uid: UInt = 0, info: String? = nil
+) async -> Int32 {
+    if await !AgoraManager.checkForPermissions() {
+        DispatchQueue.main.async {
+            self.label = """
+            Camera and microphone permissions were not granted.
+            Check your security settings and try again.
+            """
+        }
+        return -3
+    }
+
+    return self.agoraEngine.joinChannel(
+        byToken: token, channelId: channel,
+        info: info, uid: uid
+    )
+}
+```
+
+</PlatformWrapper>
+
+<PlatformWrapper platform="macos">
+``` swift
+// This method is specifically used by the sample app. If there is a tokenURL, it will attempt to retrieve a token from there.
+open func joinChannel(_ channel: String) async -> Int32 {
+    if let rtcToken = DocsAppConfig.shared.rtcToken, !rtcToken.isEmpty {
+        return self.joinChannel(
+            channel, token: DocsAppConfig.shared.rtcToken,
+            uid: DocsAppConfig.shared.uid, info: nil
+        )
+    }
+    var token: String?
+    if !DocsAppConfig.shared.tokenUrl.isEmpty {
+        do {
+            token = try await self.fetchToken(
+                from: DocsAppConfig.shared.tokenUrl, channel: channel, role: self.role
+            )
+        } catch {
+            print("token server fetch failed: \(error.localizedDescription)")
+        }
+    }
+    return self.joinChannel(channel, token: token, uid: DocsAppConfig.shared.uid, info: nil)
+}
+// Joins a channel, starting the connection to a session.
+open func joinChannel(
+    _ channel: String, token: String? = nil, uid: UInt = 0, info: String? = nil
+) -> Int32 {
+    self.agoraEngine.joinChannel(byToken: token, channelId: channel, info: info, uid: uid)
+}
+```
+</PlatformWrapper>
+

assets/code/video-sdk/ensure-channel-quality/swift/implement-call-quality-view.mdx

@@ -0,0 +1,25 @@
+
+    ``` swift
+    public override func setupEngine() -> AgoraRtcEngineKit {
+        let engine = super.setupEngine()
+
+        // Set Audio Scenario
+        engine.setAudioScenario(.gameStreaming)
+
+        // Enable dual stream mode
+        engine.setDualStreamMode(.enableSimulcastStream)
+        engine.setAudioProfile(.default)
+
+        // Set the video configuration
+        let videoConfig = AgoraVideoEncoderConfiguration(
+            size: CGSize(width: 640, height: 360),
+            frameRate: .fps10,
+            bitrate: AgoraVideoBitrateStandard,
+            orientationMode: .adaptative,
+            mirrorMode: .auto
+        )
+        engine.setVideoEncoderConfiguration(videoConfig)
+
+        return engine
+    }
+    ```

assets/code/video-sdk/get-started-sdk/swift/handle-events.mdx

@@ -0,0 +1,17 @@
+
+``` swift
+open func rtcEngine(_ engine: AgoraRtcEngineKit, didJoinChannel channel: String, withUid uid: UInt, elapsed: Int) {
+    self.localUserId = uid
+    if self.role == .broadcaster {
+        self.allUsers.insert(uid)
+    }
+}
+
+open func rtcEngine(_ engine: AgoraRtcEngineKit, didJoinedOfUid uid: UInt, elapsed: Int) {
+    self.allUsers.insert(uid)
+}
+
+open func rtcEngine(_ engine: AgoraRtcEngineKit, didOfflineOfUid uid: UInt, reason: AgoraUserOfflineReason) {
+    self.allUsers.remove(uid)
+}
+```

assets/code/video-sdk/get-started-sdk/swift/join-channel.mdx

@@ -0,0 +1,39 @@
+
+``` swift
+open func joinChannel(
+    _ channel: String, token: String? = nil, uid: UInt = 0, info: String? = nil
+) async -> Int32 {
+    if await !AgoraManager.checkForPermissions() {
+        DispatchQueue.main.async {
+            self.label = """
+            Camera and microphone permissions were not granted.
+            Check your security settings and try again.
+            """
+        }
+        return -3
+    }
+
+    return self.agoraEngine.joinChannel(
+        byToken: token, channelId: channel,
+        info: info, uid: uid
+    )
+}
+
+// This method is specifically used by the sample app. If there is a tokenURL, it will attempt to retrieve a token from there.
+internal func joinChannel(_ channel: String, uid: UInt? = nil) async -> Int32 {
+    let userId = uid ?? DocsAppConfig.shared.uid
+    var token = DocsAppConfig.shared.rtcToken
+    if !DocsAppConfig.shared.tokenUrl.isEmpty {
+        do {
+            token = try await self.fetchToken(
+                from: DocsAppConfig.shared.tokenUrl, channel: channel,
+                role: self.role, userId: userId
+            )
+        } catch {
+            print("token server fetch failed: \(error.localizedDescription)")
+        }
+    }
+    return await self.joinChannel(channel, token: token, uid: userId, info: nil)
+}
+```
+

assets/code/video-sdk/get-started-sdk/swift/leave-channel.mdx

@@ -0,0 +1,13 @@
+
+``` swift
+open func leaveChannel(
+    leaveChannelBlock: ((AgoraChannelStats) -> Void)? = nil,
+    destroyInstance: Bool = true
+) -> Int32 {
+    let leaveErr = self.agoraEngine.leaveChannel(leaveChannelBlock)
+    self.agoraEngine.stopPreview()
+    defer { if destroyInstance { AgoraRtcEngineKit.destroy() } }
+    self.allUsers.removeAll()
+    return leaveErr
+}
+```

assets/images/signaling/get-started-workflow.puml

@@ -15,7 +15,7 @@ end box
 group Initialize
 USR -> APP: Open app
 APP -> APP: Create a signalingEngine instance
-APP -> APP: Add event callbacks
+APP -> APP: Add event listeners
 APP -> APP: Set the authentication token
 APP -> API: Log in to Signaling
 end
@@ -29,15 +29,6 @@ API -> APP: message
 APP -> USR: Receive message
 end
 
-group Presence
-
-USR -> APP: Change status
-APP -> APP: listen for user events
-API -> APP: ConnectionStateChanged
-APP -> USR: Inform users
-
-end
-
 group Close
 USR -> APP: Log out
 APP -> API: Log out of Signaling