MCSession Multiple Clients Issue

2024-11-01 15:42 UTC gpt-4o Open in ChatGPT ↗

You

why is it impossible for a second client to connect to the host?

import UIKit import SwiftUI import NearbyInteraction import MultipeerConnectivity import CoreBluetooth import AVFoundation import CoreMotion

class ViewController: UIViewController, NISessionDelegate, MCSessionDelegate, MCNearbyServiceAdvertiserDelegate, MCNearbyServiceBrowserDelegate, CBCentralManagerDelegate, AVAudioRecorderDelegate {

// MARK: - Properties

var niSessions: [MCPeerID: NISession] = [:] var mcSession: MCSession? var peerID: MCPeerID? var mcAdvertiser: MCNearbyServiceAdvertiser? var mcBrowser: MCNearbyServiceBrowser? var connectedPeers: [MCPeerID: NIDiscoveryToken] = [:] var distanceLabels: [MCPeerID: UILabel] = [:] var centralManager: CBCentralManager? var motionManager = MotionManager() var isMovementDetectionEnabled = true var taskId: UIBackgroundTaskIdentifier = .invalid var username: String?

// Properties for sound playback var audioEngine = AVAudioEngine() var audioPlayerNode = AVAudioPlayerNode() var audioFile: AVAudioFile? var recordedSoundURL: URL? // Only one recorded sound URL var currentTimeGap: TimeInterval = 1.0 // Initial gap var playbackTimer: Timer? var delayEffect = AVAudioUnitDelay()

// AVAudioRecorder properties var audioRecorder: AVAudioRecorder? var isRecording: Bool = false var levelTimer: Timer?

// Boolean to distinguish host and joiner var isHost: Bool = false

// UI Elements var recordButton: UIButton?

// Timer to disable echo effect after a period var echoResetTimer: Timer?

// MARK: - View Lifecycle

override func viewDidLoad() { super.viewDidLoad()

   // Initialize Central Manager for Bluetooth permissions
   centralManager = CBCentralManager(delegate: self, queue: nil)

   // Observe app state changes
   NotificationCenter.default.addObserver(
       self,
       selector: #selector(applicationWillEnterBackground),
       name: UIApplication.didEnterBackgroundNotification,
       object: nil
   )
   NotificationCenter.default.addObserver(
       self,
       selector: #selector(applicationWillEnterForeground),
       name: UIApplication.willEnterForegroundNotification,
       object: nil
   )
   NotificationCenter.default.addObserver(
       self,
       selector: #selector(applicationWillTerminate),
       name: UIApplication.willTerminateNotification,
       object: nil
   )

   // Check if Nearby Interaction is supported
   if !NISession.isSupported {
       let alert = UIAlertController(
           title: "Unsupported Device",
           message: "This device does not support Nearby Interaction.",
           preferredStyle: .alert
       )
       self.present(alert, animated: true, completion: nil)
       return
   }

   // Ensure that the device supports UWB (iPhone 11 or later)
   if !isUWBSupported() {
       let alert = UIAlertController(
           title: "Unsupported Device",
           message: "This device does not support Ultra-Wideband (UWB) required for Nearby Interaction.",
           preferredStyle: .alert
       )
       self.present(alert, animated: true, completion: nil)
       return
   }

   // Request microphone permissions
   AVAudioSession.sharedInstance().requestRecordPermission { granted in
       if !granted {
           DispatchQueue.main.async {
               let alert = UIAlertController(
                   title: "Microphone Access Denied",
                   message: "Please enable microphone access in Settings.",
                   preferredStyle: .alert
               )
               alert.addAction(UIAlertAction(title: "OK", style: .default))
               self.present(alert, animated: true)
           }
       }
   }

}

override func viewDidAppear(_ animated: Bool) { super.viewDidAppear(animated)

   // Show login interface if the username is not set
   if username == nil {
       DispatchQueue.main.async {
           self.showRoleSelectionInterface()
       }
   }

}

override func viewDidDisappear(_ animated: Bool) { super.viewDidDisappear(animated) // motionManager.stopAccelerometerUpdates() }

// MARK: - Device Compatibility Check

func isUWBSupported() -> Bool { // Check if the device supports UWB let supportedDeviceModels: [String] = [ “iPhone12,1”, // iPhone 11 “iPhone12,3”, // iPhone 11 Pro “iPhone12,5”, // iPhone 11 Pro Max “iPhone13,1”, // iPhone 12 mini “iPhone13,2”, // iPhone 12 “iPhone13,3”, // iPhone 12 Pro “iPhone13,4”, // iPhone 12 Pro Max “iPhone14,4”, // iPhone 13 mini “iPhone14,5”, // iPhone 13 “iPhone14,2”, // iPhone 13 Pro “iPhone14,3”, // iPhone 13 Pro Max “iPhone14,7”, // iPhone 14 “iPhone14,8”, // iPhone 14 Plus “iPhone15,2”, // iPhone 14 Pro “iPhone15,3”, // iPhone 14 Pro Max // Add more models as needed ]

   var systemInfo = utsname()
   uname(&systemInfo)
   let machineMirror = Mirror(reflecting: systemInfo.machine)
   let modelCode = machineMirror.children.reduce("") { identifier, element in
       guard let value = element.value as? Int8, value != 0 else {
           return identifier
       }
       return identifier + String(UnicodeScalar(UInt8(value)))
   }

   return supportedDeviceModels.contains(modelCode)

}

func enableEchoEffect() { // Configure the delay effect parameters delayEffect.wetDryMix = 80 // Percentage of echo effect (0 to 100) delayEffect.delayTime = 0.5 // Delay time in seconds delayEffect.feedback = 60 // Feedback percentage

   print("Echo effect enabled")

   // Reset the echo effect after a period
   echoResetTimer?.invalidate()
   echoResetTimer = Timer.scheduledTimer(
       timeInterval: 5.0, // Duration of echo effect
       target: self,
       selector: #selector(disableEchoEffect),
       userInfo: nil,
       repeats: false
   )

}

@objc func disableEchoEffect() { delayEffect.wetDryMix = 0 delayEffect.feedback = 0 print(“Echo effect disabled”) }

// MARK: - UI Setup

func showRoleSelectionInterface() { let alertController = UIAlertController( title: “Select Role”, message: “Do you want to Host or Join a session?”, preferredStyle: .alert )

   let hostAction = UIAlertAction(title: "Host", style: .default) { _ in
       self.isHost = true
       self.showLoginInterface()
   }

   let joinAction = UIAlertAction(title: "Join", style: .default) { _ in
       self.isHost = false
       self.showLoginInterface()
   }

   alertController.addAction(hostAction)
   alertController.addAction(joinAction)

   present(alertController, animated: true)

}

func showLoginInterface() { let role = isHost ? “Host” : “Joiner” let alertController = UIAlertController( title: “Login ((role))”, message: “Enter your username”, preferredStyle: .alert )

   alertController.addTextField { textField in
       textField.placeholder = "Username"
   }

   let loginAction = UIAlertAction(title: "Login", style: .default) { _ in
       if let username = alertController.textFields?.first?.text,
          !username.isEmpty {
           self.username = username
           self.peerID = MCPeerID(displayName: username)
           self.setupSession()
           self.setupUI()
       } else {
           self.showLoginInterface() // Retry if username is empty
       }
   }

   alertController.addAction(loginAction)
   present(alertController, animated: true)

}

func setupSession() { guard let peerID = self.peerID else { print(“Error: peerID is nil in setupSession()”) return }

   mcSession = MCSession(
       peer: peerID,
       securityIdentity: nil,
       encryptionPreference: .required
   )
   mcSession?.delegate = self

   if isHost {
       startHosting()
   } else {
       startBrowsing()
   }

}

func setupUI() { // Remove any existing views for subview in view.subviews { subview.removeFromSuperview() }

   let roleLabel = UILabel()
   roleLabel.text = isHost ? "Hosting Session" : "Joining Session"
   roleLabel.textAlignment = .center
   roleLabel.frame = CGRect(
       x: 20,
       y: 50,
       width: view.frame.width - 40,
       height: 40
   )
   view.addSubview(roleLabel)

   // Add the round-shaped record button
   recordButton = UIButton(type: .custom)
  /* if let recordButton = recordButton {
       recordButton.frame = CGRect(
           x: (view.frame.width - 80) / 2,
           y: view.frame.height - 150,
           width: 80,
           height: 80
       )
       recordButton.layer.cornerRadius = 40 // Make it round
       recordButton.backgroundColor = .systemGreen // Default color is green
       recordButton.setTitle("Go To Music Toy Page", for: .normal)
       recordButton.setTitleColor(.white, for: .normal)
       recordButton.addTarget(
           self,
           action: #selector(recordButtonTouchDown),
           for: .touchDown
       )
       recordButton.addTarget(
           self,
           action: #selector(recordButtonTouchUp),
           for: [.touchUpInside, .touchUpOutside]
       )
       view.addSubview(recordButton)
   }*/
   let recordButton = UIButton(type: .custom)
          recordButton.frame = CGRect(
              x: (view.frame.width - 80) / 2,
              y: view.frame.height - 150,
              width: 80,
              height: 80
          )
          recordButton.layer.cornerRadius = 40 // Make it round
          recordButton.backgroundColor = .systemGreen // Default color is green
          recordButton.setTitle("Go", for: .normal)
          recordButton.setTitleColor(.white, for: .normal)
          recordButton.addTarget(self, action: #selector(recordButtonTapped), for: .touchUpInside)

          view.addSubview(recordButton)

   // Start playing sounds
   startPlayingSounds()

} var hostingController: UIHostingController?

@objc func recordButtonTapped() { // 打印当前的值 print(“Go to Music Toy”)

   // 创建 SwiftUI 视图并传入环境对象
   let musicToyView = MusicToyView().environmentObject(motionManager)

   // 创建 HostingController
   let hostingController = UIHostingController(rootView: musicToyView)

   // 使用 modal 方式呈现
   hostingController.modalPresentationStyle = .fullScreen // 可选，设置为全屏
   present(hostingController, animated: true, completion: nil)

}

// MARK: - Recording Audio

@objc func recordButtonTouchDown() { print(“Record button pressed”) startRecording() // Change button color to blue when recording recordButton?.backgroundColor = .systemBlue }

@objc func recordButtonTouchUp() { print(“Record button released”) stopRecording() // Change button color back to green when not recording recordButton?.backgroundColor = .systemGreen }

func startRecording() { guard !isRecording else { return }

   let audioSession = AVAudioSession.sharedInstance()
   do {
       // Set audio session category and mode
       try audioSession.setCategory(
           .playAndRecord,
           mode: .measurement,
           options: [.defaultToSpeaker]
       )
       try audioSession.setActive(true)

       // Set input gain if possible
       if audioSession.isInputGainSettable {
           try audioSession.setInputGain(1.0) // Maximum gain
       }

       // Verify audio session input
       let currentRoute = audioSession.currentRoute
       for input in currentRoute.inputs {
           print("Current input: \(input.portName)")
       }

       // Define the recording settings
       let settings: [String: Any] = [
           AVFormatIDKey: Int(kAudioFormatAppleLossless),
           AVSampleRateKey: 44100,
           AVNumberOfChannelsKey: 1,
           AVEncoderBitDepthHintKey: 16,
           AVEncoderAudioQualityKey: AVAudioQuality.max.rawValue
       ]

       // Create a unique filename for the recording
       let filename = "recording-\(Date().timeIntervalSince1970).m4a"
       let documentsDirectory = FileManager.default.urls(
           for: .documentDirectory,
           in: .userDomainMask
       )[0]
       let audioURL = documentsDirectory.appendingPathComponent(filename)

       // Initialize the recorder
       audioRecorder = try AVAudioRecorder(url: audioURL, settings: settings)
       audioRecorder?.delegate = self
       audioRecorder?.isMeteringEnabled = true
       audioRecorder?.record()

       // Start monitoring audio levels
       levelTimer = Timer.scheduledTimer(
           timeInterval: 0.1,
           target: self,
           selector: #selector(monitorAudioLevels),
           userInfo: nil,
           repeats: true
       )

       isRecording = true
       print("Started recording to \(audioURL)")
   } catch {
       print("Failed to start recording: \(error.localizedDescription)")
   }

}

@objc func monitorAudioLevels() { audioRecorder?.updateMeters() if let averagePower = audioRecorder?.averagePower(forChannel: 0) { print(“Average input power: (averagePower) dB”) } }

func stopRecording() { guard isRecording else { return }

   audioRecorder?.stop()
   isRecording = false

   // Stop the level timer
   levelTimer?.invalidate()
   levelTimer = nil

   print("Stopped recording")

}

// AVAudioRecorderDelegate method func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool) { if flag { let url = recorder.url print(“Recording saved to (url)”)

       // Delete the previous recording if it exists
       if let previousURL = recordedSoundURL {
           deleteRecordingFile(at: previousURL)
       }

       // Update the recorded sound URL to the new recording
       recordedSoundURL = url

       setupAudioPlayers() // Update the audio players with the new recording
   } else {
       print("Recording failed")
   }

}

func deleteRecordingFile(at url: URL) { do { try FileManager.default.removeItem(at: url) print(“Deleted recording at (url)”) } catch { print(“Failed to delete recording at (url): (error.localizedDescription)”) } }

// MARK: - Sound Playback

func setupAudioPlayers() { // Reset the audio engine audioEngine.stop() audioEngine.reset() audioEngine = AVAudioEngine() audioPlayerNode = AVAudioPlayerNode() delayEffect = AVAudioUnitDelay() delayEffect.wetDryMix = 0 // Start with echo effect disabled

   // Attach nodes
   audioEngine.attach(audioPlayerNode)
   audioEngine.attach(delayEffect)

   // Connect nodes
   audioEngine.connect(audioPlayerNode, to: delayEffect, format: nil)
   audioEngine.connect(delayEffect, to: audioEngine.mainMixerNode, format: nil)

   // Load the recorded sound file
   if let url = recordedSoundURL {
       do {
           audioFile = try AVAudioFile(forReading: url)
           print("Loaded sound from \(url.lastPathComponent)")
       } catch {
           print("Error loading sound from \(url.lastPathComponent): \(error)")
       }
   }

   // Prepare and start the audio engine
   do {
       try audioEngine.start()
       print("Audio engine started")

       // Set the playback volume here
       audioEngine.mainMixerNode.outputVolume = 140 // Adjust volume between 0.0 and 1.0

   } catch {
       print("Failed to start audio engine: \(error.localizedDescription)")
   }

   // Start the player node
   audioPlayerNode.play()

}

func startPlayingSounds() { if audioFile == nil { print(“No sounds available to play”) return }

   // Configure audio session for playback
   let audioSession = AVAudioSession.sharedInstance()
   do {
       try audioSession.setCategory(.playback, mode: .default, options: [])
       try audioSession.setActive(true)
   } catch {
       print("Failed to activate audio session for playback: \(error.localizedDescription)")
   }

   startPlaybackTimer()

}

func stopPlayingSounds() { playbackTimer?.invalidate() playbackTimer = nil audioPlayerNode.stop() audioEngine.stop() }

func startPlaybackTimer() { playbackTimer?.invalidate() // Invalidate existing timer if any playbackTimer = Timer.scheduledTimer( timeInterval: currentTimeGap, target: self, selector: #selector(playNextSound), userInfo: nil, repeats: true ) print(“Started playback timer with interval (currentTimeGap) seconds”) }

@objc func playNextSound() { guard let audioFile = audioFile else { return }

   // Schedule the audio file to play without stopping previous playback
   audioPlayerNode.scheduleFile(audioFile, at: nil, completionHandler: nil)
   print("Playing sound")

   // If host, send a message to joiners
   if isHost {
       // Send a message to connected peers
       if let mcSession = mcSession, mcSession.connectedPeers.count > 0 {
           // Create a dictionary with the time gap
           let message = [
               "command": "playSound",
               "timeGap": currentTimeGap
           ] as [String: Any]
           do {
               let data = try JSONSerialization.data(
                   withJSONObject: message,
                   options: []
               )
               try mcSession.send(
                   data,
                   toPeers: mcSession.connectedPeers,
                   with: .reliable
               )
               print("Host sent playSound message to joiners")
           } catch {
               print("Error sending playSound message: \(error)")
           }
       }
   }

}

func playSoundFromJoiner() { if let audioFile = audioFile { // Schedule the audio file to play without stopping previous playback audioPlayerNode.scheduleFile(audioFile, at: nil, completionHandler: nil) print(“Joiner playing sound”) } else { print(“No sound available to play”) } }

func updateSoundPlayback(forDistance distance: Float) { let newTimeGap = calculateTimeGap(forDistance: Double(distance))

   if abs(newTimeGap - currentTimeGap) > 0.01 {
       currentTimeGap = newTimeGap
       print("Updated time gap to \(currentTimeGap) seconds for distance \(distance) meters")

       startPlaybackTimer() // Restart timer with new time gap
   }

   // Optional: Adjust volume based on distance
   // Uncomment the following lines to enable volume adjustment based on distance

   /*
   let newVolume = calculateVolume(forDistance: Double(distance))
   audioEngine.mainMixerNode.outputVolume = newVolume
   print("Adjusted volume to \(newVolume) for distance \(distance) meters")
   */

}

func calculateTimeGap(forDistance distance: Double) -> TimeInterval { // Adjust time gap calculation as needed // For example, map the distance to a time gap between 0.5 and 2.0 seconds let minGap: TimeInterval = 0.5 let maxGap: TimeInterval = 2.0 let maxDistance: Double = 5.0 // Maximum expected distance

   let normalizedDistance = min(distance / maxDistance, 1.0)
   let timeGap = minGap + (maxGap - minGap) * normalizedDistance

   return timeGap

}

// Optional: Calculate volume based on distance func calculateVolume(forDistance distance: Double) -> Float { let maxDistance: Double = 5.0 // Maximum expected distance let normalizedDistance = min(distance / maxDistance, 1.0) let volume = Float(1.0 - normalizedDistance) // Inverse relationship

   return volume

}

// MARK: - NISessionDelegate

// MARK: - NISessionDelegate

func session(_ session: NISession, didUpdate nearbyObjects: [NINearbyObject]) { print(“session didUpdate called”) DispatchQueue.main.async { for nearbyObject in nearbyObjects { guard let distance = nearbyObject.distance else { print(“No distance information available.”) continue } //matt22221111

           print("Received distance: \(distance) meters")
           SharedData.tempoValue = distance
           self.updateSoundPlayback(forDistance: distance)

           if let peerID = self.niSessions.first(where: { $0.value == session })?.key {
               if let label = self.distanceLabels[peerID] {
                   label.text = "\(peerID.displayName): \(String(format: "%.2f", distance)) meters"
               } else {
                   let label = UILabel()
                   label.text = "\(peerID.displayName): \(String(format: "%.2f", distance)) meters"
                   label.frame = CGRect(
                       x: 20,
                       y: 100 + (self.distanceLabels.count * 40),
                       width: 300,
                       height: 40
                   )
                   self.view.addSubview(label)
                   self.distanceLabels[peerID] = label
               }
           }
       }
   }

}

func session(_ session: NISession, didInvalidateWith error: Error) { print(“session didInvalidateWith called with error: (error.localizedDescription)”) if let peerID = niSessions.first(where: { $0.value == session })?.key { let nsError = error as NSError print(“NISession invalidated for peer (peerID.displayName) with error: (error.localizedDescription)”) print(“Error code: (nsError.code), domain: (nsError.domain)”)

       // Handle specific NIError codes
       if nsError.domain == NIErrorDomain,
          let niErrorCode = NIError.Code(rawValue: nsError.code) {
           switch niErrorCode {
           case .userDidNotAllow:
               print("User did not allow Nearby Interaction access.")
               // Prompt user to enable permissions
               DispatchQueue.main.async {
                   let alert = UIAlertController(
                       title: "Permission Denied",
                       message: "Please enable Nearby Interaction permissions in Settings.",
                       preferredStyle: .alert
                   )
                   alert.addAction(UIAlertAction(
                       title: "Open Settings",
                       style: .default,
                       handler: { _ in
                           if let appSettings = URL(string: UIApplication.openSettingsURLString) {
                               UIApplication.shared.open(appSettings)
                           }
                       }
                   ))
                   alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
                   self.present(alert, animated: true)
               }
           case .sessionFailed:
               print("Session failed due to an internal error.")
               // Attempt to restart the session
               self.restartNISession(for: peerID)
           default:
               print("An unknown error occurred.")
               // Attempt to restart the session
               self.restartNISession(for: peerID)
           }
       } else {
           // For other errors, attempt to restart the session
           self.restartNISession(for: peerID)
       }
   }

}

func sessionWasSuspended(_ session: NISession) { print(“sessionWasSuspended called”) }

func sessionSuspensionEnded(_ session: NISession) { print(“sessionSuspensionEnded called”) if let peerID = niSessions.first(where: { $0.value == session })?.key, let token = connectedPeers[peerID] { let config = NINearbyPeerConfiguration(peerToken: token) session.run(config) } }

func session(_ session: NISession, didGenerateShareableConfigurationData data: Data, for object: NINearbyObject) { // This method is not used in this implementation }

// MARK: - MCSessionDelegate

func session(_ session: MCSession, peer peerID: MCPeerID, didChange state: MCSessionState) { DispatchQueue.main.async { switch state { case .connected: if self.isHost { print(“Host connected to (peerID.displayName)”) // Create NISession for this peer if let _ = self.createNISession(for: peerID) { self.sendDiscoveryToken(to: peerID) } } else { if session.connectedPeers.count > 1 { print(“Joiner can only connect to one host. Disconnecting from (peerID.displayName).”) session.cancelConnectPeer(peerID) } else { print(“Connected to host: (peerID.displayName)”) // Create NISession for this peer if let _ = self.createNISession(for: peerID) { self.sendDiscoveryToken(to: peerID) } } } case .connecting: print(“Connecting to (peerID.displayName)”) case .notConnected: print(“Disconnected from (peerID.displayName)”) self.cleanupPeer(peerID) if !self.isHost { self.startBrowsing() } @unknown default: fatalError(“Unknown state”) } } }

func cleanupPeer(_ peerID: MCPeerID) { DispatchQueue.main.async { if let label = self.distanceLabels[peerID] { label.removeFromSuperview() self.distanceLabels.removeValue(forKey: peerID) } } self.connectedPeers.removeValue(forKey: peerID) if let session = niSessions[peerID] { session.invalidate() niSessions.removeValue(forKey: peerID) } }

func session(_ session: MCSession, didReceive data: Data, fromPeer peerID: MCPeerID) { // First, try to unarchive data as NIDiscoveryToken do { if let token = try NSKeyedUnarchiver.unarchivedObject( ofClass: NIDiscoveryToken.self, from: data ) { connectedPeers[peerID] = token exchangeDiscoveryTokens(with: peerID, token: token) return } } catch { // Not a discovery token, proceed to check if it’s a JSON message }

   // Try to parse data as JSON message
   do {
       if let message = try JSONSerialization.jsonObject(
           with: data, options: []
       ) as? [String: Any],
          let command = message["command"] as? String {

           if command == "playSound" {
               // Handle playSound command
               if !isHost {
                   if let timeGap = message["timeGap"] as? TimeInterval {
                       self.currentTimeGap = timeGap // Update the time gap
                       // Schedule sound playback after half the time gap
                       let delay = timeGap / 2
                       DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
                           self.playSoundFromJoiner()
                       }
                       print("Joiner scheduled sound playback after \(delay) seconds")
                   }
               }
           }
       } else {
           print("Received invalid data from \(peerID.displayName)")
       }
   } catch {
       print("Failed to decode message from \(peerID.displayName): \(error.localizedDescription)")
   }

}

// Other MCSessionDelegate methods (unused in this context) func session(_ session: MCSession, didStartReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, with progress: Progress) {}

func session(_ session: MCSession, didFinishReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, at localURL: URL?, withError error: Error?) {}

func session(_ session: MCSession, didReceive stream: InputStream, withName streamName: String, fromPeer peerID: MCPeerID) {}

func session(_ session: MCSession, didReceiveCertificate certificate: [Any]?, fromPeer peerID: MCPeerID, certificateHandler: @escaping (Bool) -> Void) { certificateHandler(true) }

// MARK: - MCNearbyServiceAdvertiserDelegate

func advertiser(_ advertiser: MCNearbyServiceAdvertiser, didNotStartAdvertisingPeer error: Error) { print(“Failed to start advertising: (error.localizedDescription)”) }

func advertiser(_ advertiser: MCNearbyServiceAdvertiser, didReceiveInvitationFromPeer peerID: MCPeerID, withContext context: Data?, invitationHandler: @escaping (Bool, MCSession?) -> Void) { if isHost { invitationHandler(true, mcSession) } else { invitationHandler(false, nil) } }

// MARK: - MCNearbyServiceBrowserDelegate

func browser(_ browser: MCNearbyServiceBrowser, foundPeer peerID: MCPeerID, withDiscoveryInfo info: [String: String]?) { print(“Found peer: (peerID.displayName)”) if !isHost && mcSession?.connectedPeers.count == 0 { browser.invitePeer( peerID, to: mcSession!, withContext: nil, timeout: 30 // Increased timeout ) } }

func browser(_ browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID) { print(“Lost peer: (peerID.displayName)”) }

// MARK: - NISession Management

func createNISession(for peerID: MCPeerID) -> NISession? { // Create a new NISession for this peer let session = NISession() session.delegate = self niSessions[peerID] = session print(“Created NISession for (peerID.displayName)”)

   // Wait a moment before sending the discovery token
   DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
       self.sendDiscoveryToken(to: peerID)
   }

   return session

}

func sendDiscoveryToken(to peerID: MCPeerID, retryCount: Int = 0) { guard let session = niSessions[peerID] else { print(“NISession not available for (peerID.displayName)”) return }

   guard let discoveryToken = session.discoveryToken else {
       if retryCount < 10 { // Increase the retry limit
           print("Discovery token not yet available for \(peerID.displayName). Retrying (\(retryCount + 1))...")
           // Retry after a longer delay
           DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
               self.sendDiscoveryToken(to: peerID, retryCount: retryCount + 1)
           }
       } else {
           print("Failed to obtain discovery token for \(peerID.displayName) after multiple attempts.")
           // Handle the failure appropriately
           self.cleanupPeer(peerID)
       }
       return
   }

   guard let mcSession = mcSession else {
       print("MCSession is not initialized.")
       return
   }

   if !mcSession.connectedPeers.contains(peerID) {
       print("Cannot send discovery token to \(peerID.displayName): Peer is not connected.")
       return
   }

   do {
       let data = try NSKeyedArchiver.archivedData(
           withRootObject: discoveryToken,
           requiringSecureCoding: true
       )
       try mcSession.send(data, toPeers: [peerID], with: .reliable)
       print("Sent discovery token to \(peerID.displayName)")
   } catch {
       print("Failed to send discovery token to \(peerID.displayName): \(error.localizedDescription)")
   }

}

func exchangeDiscoveryTokens(with peerID: MCPeerID, token: NIDiscoveryToken) { if let session = niSessions[peerID] { let config = NINearbyPeerConfiguration(peerToken: token) session.run(config) print(“Exchanged tokens and started NI session with (peerID.displayName)”) } else { print(“NISession not found for (peerID.displayName)”) } }

func restartNISession(for peerID: MCPeerID) { // Invalidate the old session if let oldSession = niSessions[peerID] { oldSession.invalidate() niSessions.removeValue(forKey: peerID) }

   // Create a new session
   if let _ = createNISession(for: peerID) {
       // Wait a moment before sending the discovery token
       DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
           self.sendDiscoveryToken(to: peerID)
       }
       print("Restarted NI session with \(peerID.displayName)")
   }

}

// MARK: - App State Handling

@objc func applicationWillEnterBackground() { // stopAccelerometerUpdates() stopPlayingSounds() // Begin background task if needed taskId = UIApplication.shared.beginBackgroundTask(expirationHandler: { UIApplication.shared.endBackgroundTask(self.taskId) self.taskId = .invalid }) }

@objc func applicationWillEnterForeground() { // startAccelerometerUpdates() // Start playing sounds startPlayingSounds() if taskId != .invalid { UIApplication.shared.endBackgroundTask(taskId) taskId = .invalid } }

@objc func applicationWillTerminate() { shutdownMultiPeerStuff() }

func shutdownMultiPeerStuff() { stopAdvertisingAndBrowsing() mcSession?.disconnect() for (_, session) in niSessions { session.invalidate() } niSessions.removeAll() }

// MARK: - Hosting and Browsing

func startHosting() { stopAdvertisingAndBrowsing() // Clean-up before starting guard let peerID = self.peerID else { print(“Error: peerID is nil in startHosting()”) return } mcAdvertiser = MCNearbyServiceAdvertiser( peer: peerID, discoveryInfo: nil, serviceType: “uwb-distance” ) mcAdvertiser?.delegate = self mcAdvertiser?.startAdvertisingPeer() print(“Started hosting successfully.”) }

func startBrowsing() { stopAdvertisingAndBrowsing() // Clean-up before starting guard let peerID = self.peerID else { print(“Error: peerID is nil in startBrowsing()”) return } mcBrowser = MCNearbyServiceBrowser( peer: peerID, serviceType: “uwb-distance” ) mcBrowser?.delegate = self mcBrowser?.startBrowsingForPeers() print(“Started browsing for peers.”) }

func stopAdvertisingAndBrowsing() { mcAdvertiser?.stopAdvertisingPeer() mcAdvertiser = nil mcBrowser?.stopBrowsingForPeers() mcBrowser = nil }

// MARK: - CBCentralManagerDelegate

func centralManagerDidUpdateState(_ central: CBCentralManager) { switch central.state { case .poweredOn: print(“Bluetooth is On”) case .poweredOff: print(“Bluetooth is Off”) case .resetting: print(“Bluetooth is Resetting”) case .unauthorized: print(“Bluetooth is Unauthorized”) case .unsupported: print(“Bluetooth is Unsupported”) case .unknown: print(“Bluetooth is Unknown”) @unknown default: fatalError(“Unknown Bluetooth state”) } } }

ChatGPT

In your code, the issue preventing a second client from connecting to the host likely arises from how MCSession is configured and the handling of peerIDs, which restricts joiners to a single host connection. Here are the main points contributing to this:

1. Single Peer Connection on Joiners: Within the MCSessionDelegate method session(_:peer:didChange:), when the peer state changes to .connected, a check limits mcSession connections for joiners. This block of code:

   if session.connectedPeers.count > 1 {
       print("Joiner can only connect to one host. Disconnecting from $peerID.displayName).")
       session.cancelConnectPeer(peerID)
   }

   prevents any joiner from connecting to more than one host. So, if this is intended as a host-client setup where only one client connects to one host, this is fine. However, if you want multiple clients to join a single host, removing or adjusting this condition might help.

2. MCNearbyServiceAdvertiser and MCNearbyServiceBrowser: When a host advertises, clients can browse and connect. However, when a client connects, the advertiser(_:didReceiveInvitationFromPeer:withContext:invitationHandler:) function currently has this line:

   invitationHandler(isHost, mcSession)

   For a host-only setup, this limits acceptance of invites solely to hosts, denying clients the ability to invite other clients. If you intend for multiple connections, revising this to selectively permit multiple client joins would be necessary.

3. Host-Client Protocol Logic: The distinction in isHost setup and startHosting vs. startBrowsing logic enforces a strict “host can only connect with one client” restriction. To allow more clients, you may need to:

   • Change the protocol to dynamically handle multiple connections if desired,
   • Or reconfigure the app to manage peer sessions and delegate updates differently for each connecting client. This might involve changing the app from a strict “host-joiner” approach to a multi-peer session where multiple clients can join the host.

To allow multiple clients to connect, try the following steps:

• Remove or adjust the check in session(_:peer:didChange:) so it no longer disconnects additional clients.
• Adjust advertiser(_:didReceiveInvitationFromPeer:withContext:invitationHandler:) to allow client join requests in addition to host invites.

Let me know if you’d like help refining these specific parts!

You

describe exactly which functions to modufy

ChatGPT

To modify your code so that multiple clients can connect to a single host, you’ll need to focus on a few key functions. Here’s a breakdown of each function you’ll need to adjust or review to allow multiple clients to connect to the host:

1. Modify session(_:peer:didChange:)

The session(_:peer:didChange:) method currently disconnects clients if more than one tries to connect. To allow multiple clients to connect, remove the disconnect logic for clients.

Current Code

func session(_ session: MCSession, peer peerID: MCPeerID, didChange state: MCSessionState) {
    DispatchQueue.main.async {
        switch state {
        case .connected:
            if self.isHost {
                print("Host connected to $peerID.displayName)")
                if let _ = self.createNISession(for: peerID) {
                    self.sendDiscoveryToken(to: peerID)
                }
            } else {
                if session.connectedPeers.count > 1 {
                    print("Joiner can only connect to one host. Disconnecting from $peerID.displayName).")
                    session.cancelConnectPeer(peerID)
                } else {
                    print("Connected to host: $peerID.displayName)")
                    if let _ = self.createNISession(for: peerID) {
                        self.sendDiscoveryToken(to: peerID)
                    }
                }
            }
        case .connecting:
            print("Connecting to $peerID.displayName)")
        case .notConnected:
            print("Disconnected from $peerID.displayName)")
            self.cleanupPeer(peerID)
            if !self.isHost {
                self.startBrowsing()
            }
        @unknown default:
            fatalError("Unknown state")
        }
    }
}

Modified Code

Remove the check for session.connectedPeers.count > 1 so that clients are not limited to connecting only to one host.

func session(_ session: MCSession, peer peerID: MCPeerID, didChange state: MCSessionState) {
    DispatchQueue.main.async {
        switch state {
        case .connected:
            if self.isHost {
                print("Host connected to $peerID.displayName)")
                if let _ = self.createNISession(for: peerID) {
                    self.sendDiscoveryToken(to: peerID)
                }
            } else {
                print("Connected to host: $peerID.displayName)")
                if let _ = self.createNISession(for: peerID) {
                    self.sendDiscoveryToken(to: peerID)
                }
            }
        case .connecting:
            print("Connecting to $peerID.displayName)")
        case .notConnected:
            print("Disconnected from $peerID.displayName)")
            self.cleanupPeer(peerID)
            if !self.isHost {
                self.startBrowsing()
            }
        @unknown default:
            fatalError("Unknown state")
        }
    }
}

2. Modify advertiser(_:didReceiveInvitationFromPeer:withContext:invitationHandler:)

Currently, this method accepts invitations only if isHost is true. To allow clients to join the host without restrictions, ensure that only the host accepts invitations while clients always decline them.

Current Code

func advertiser(_ advertiser: MCNearbyServiceAdvertiser,
                didReceiveInvitationFromPeer peerID: MCPeerID,
                withContext context: Data?,
                invitationHandler: @escaping (Bool, MCSession?) -> Void) {
    if isHost {
        invitationHandler(true, mcSession)
    } else {
        invitationHandler(false, nil)
    }
}

Modified Code

Keep this code as it is, as the current behavior ensures only the host will accept connections from clients. Clients will not accept invitations, which maintains a clean host-client relationship.

3. Modify startHosting() and startBrowsing() Methods

Ensure the startHosting() and startBrowsing() methods are configured so that the host advertises correctly and clients browse without restriction. Here are some checks for these functions:

startHosting()

Confirm that the host starts advertising without restrictions, and that mcAdvertiser is properly initialized and started for the host:

func startHosting() {
    stopAdvertisingAndBrowsing()
    guard let peerID = self.peerID else {
        print("Error: peerID is nil in startHosting()")
        return
    }
    mcAdvertiser = MCNearbyServiceAdvertiser(
        peer: peerID,
        discoveryInfo: nil,
        serviceType: "uwb-distance"
    )
    mcAdvertiser?.delegate = self
    mcAdvertiser?.startAdvertisingPeer()
    print("Started hosting successfully.")
}

startBrowsing()

Verify that clients start browsing without restrictions and that mcBrowser is correctly initialized and started for browsing:

func startBrowsing() {
    stopAdvertisingAndBrowsing()
    guard let peerID = self.peerID else {
        print("Error: peerID is nil in startBrowsing()")
        return
    }
    mcBrowser = MCNearbyServiceBrowser(
        peer: peerID,
        serviceType: "uwb-distance"
    )
    mcBrowser?.delegate = self
    mcBrowser?.startBrowsingForPeers()
    print("Started browsing for peers.")
}

4. Ensure MCNearbyServiceAdvertiserDelegate and MCNearbyServiceBrowserDelegate Handle Multiple Connections Properly

No further modifications are required in MCNearbyServiceAdvertiserDelegate or MCNearbyServiceBrowserDelegate for basic multi-client functionality, as they are configured to allow multiple peers to discover and connect.

Summary of Modifications

1. Remove the disconnect check for multiple connections in session(_:peer:didChange:).
2. Retain the invitation acceptance only for the host in advertiser(_:didReceiveInvitationFromPeer:withContext:invitationHandler:).
3. Ensure proper configuration for startHosting() and startBrowsing() so that the host advertises and clients browse correctly.