User Profile

Yes, they both have the same exact code. Btw neither device receives the echo but they both receive that first message. Here is startOutgoingConnection, actually here is PeerConnection because it is 1 class that has 2 initializers, one for outgoing and one for incoming. I put break points everywhere but nada on that 2nd incoming message. protocol PeerConnectionDelegate: class {     func sendOutgoing(_ connection: NWConnection)     func receivedIncoming(_ connection: NWConnection) } class PeerConnection: Hashable {     static func == (lhs: PeerConnection, rhs: PeerConnection) - Bool {         return lhs.connection?.endpoint.debugDescription == rhs.connection?.endpoint.debugDescription     }     func hash(into hasher: inout Hasher) {         guard let connection = connection else { return }         hasher.combine(connection.endpoint.debugDescription)     }     weak var delegate: PeerConnectionDelegate?     public var connection: NWConnection? // Outgoing     init(endPoint: NWEndpoint, delegate: PeerConnectionDelegate) {         self.delegate = delegate         let tcpOptions = NWProtocolTCP.Options()         tcpOptions.enableKeepalive = true         tcpOptions.keepaliveIdle = 2         let parameters = NWParameters(tls: nil, tcp: tcpOptions)         parameters.includePeerToPeer = true         parameters.allowLocalEndpointReuse = true         connection = NWConnection(to: endPoint, using: parameters)         startOutgoingConnection()     } // Incoming     init(connection: NWConnection, delegate: PeerConnectionDelegate) {         self.delegate = delegate         self.connection = connection         startIncomingConnection()     }     func startIncomingConnection() {         guard let connection = connection else { return }         connection.stateUpdateHandler = { [weak self](nwConnectionState) in             switch nwConnectionState {             case .preparing: print("preparing")             case .setup: print("setting up")             case .waiting(let error): print("\(error.localizedDescription)")             case .ready:                 self?.delegate?.receivedIncoming(connection)             case .cancelled:                 connection.cancel() // remove incoming connection from an array that holds it/them and remove corresponding cell             case .failed(let error):                 connection.cancel()                 // remove incoming connection from an array that holds it/them and remove corresponding cell             default:break             }         }         connection.start(queue: .main)     }     func startOutgoingConnection() {         guard let connection = connection else { return }         connection.stateUpdateHandler = { [weak self](nwConnectionState) in             switch nwConnectionState {             case .preparing: print("preparing")             case .setup: print("setting up")             case .waiting(let error): print(error.localizedDescription)             case .ready:                 self?.delegate?.sendOutgoing(connection)             case .cancelled:                 connection.cancel() // remove outgoing connection from an array that holds it/them             case .failed(let error):                 connection.cancel() // remove outgoing connection from an array that holds it/them             default:break             }         }         connection.start(queue: .main)     } } The connection isn't failing on either end/device because once it is cancelled I remove data from both devices which never happens after they both send and receive messages from each other. For example Device_A sends its info to Device_B and vice versa. I have a cell that shows the connection info String data like connection.endpoint.debugDescription and the uid from the opposite device. Once either device goes to the background and the connection is cancelled then both devices remove the corresponding cell. If the connection was cancelled after the initial send/receive then both cells (the cell on each device) would immediately disappear.

@eskimo Thanks for the reply. Here are the successful print statements: The Initial Send does not send a color, it just sends some data like a String message : print("Sent") // successful After the Initial Send sends the message and it is first received, I didn't add a print statement for a successful reception but the code inside Receive data and send Echo response is successful, specifically if let data = data, !data.isEmpty { // successful only once } Inside there, the data that is decoded, only has the String message from above, the color isn't sent yet so the colorData decoding is skipped. However once the String message is received, I send an echo with the colorData connection.send(content: colorData, ... { } Inside the completionHandler of the echo, this print statement always runs: print("Color data sent") // successful At that point the other device, the Receive Data receives nothing, there isn't a response whatsoever. Nothing prints, it's as if the connection got cut off after the first reception. I put breakpoints everywhere but none of them get hit.

I forgot to add the listener code let tcpOptions = NWProtocolTCP.Options() tcpOptions.enableKeepalive = true tcpOptions.keepaliveIdle = 2 let parameters = NWParameters(tls: nil, tcp: tcpOptions) parameters.includePeerToPeer = true parameters.allowLocalEndpointReuse = true

I couldn't add these because the Edit button disappeared. 1- For clarity sendDataWhenNewDeviceIsDiscovered() {...} will run every time a new device is discovered but there will only be 20 sessions at a time. This won't stop it from running but the incomingData will never be added if the sessions are at 20. 2- In place of: var sessions = [MyAppUserID: NISession]() I used: var sessions = [String: NISession]() The problem is because the current user's userId is always the key, it will only have one key the will write always over its value self.sessions[currentUserId] = session I wasn't sure what was supposed to happen here. Did you mean: var sessions = [NISession: MyAppUserID]() or var sessions = [NISession: String]()

It turns out this seems to be an issue with the simulator. I've been playing around and searching the internet for 12 hrs and nothing. I finally tried it out on my real device and 2 simulators. I sent the real device to the background and the connection.stateUpdateHandler's .failed and .cancelled worked fine on the simulators. On the reverse when I sent either of the simulators to the background the real device's connection.stateUpdateHandler didn't get hit. I don't have another real device on hand to try to see what happens with 2 real devices. This is a strange issue. Any ideas out there?

Here is the reason for the the multiple call problem, which isn't a problem, as explained by @eskimo here: - https://developer.apple.com/forums/thread/654953 Apple’s connect-by-name API uses a fancy algorithm to run multiple connections in parallel to see which one connects first (see RFC 8305 for - https://tools.ietf.org/html/rfc8305 some background on this)

I don't know how to edit my question but I forgot to add that I also have this set: playerItem?.preferredForwardBufferDuration = TimeInterval(1.0)

I followed this answerhttps://stackoverflow.com/a/52666724/4833705Settings > Your Name (Apple ID, iCloud & App Store) > iTunes & App StoreThere you will find a section called "SANDBOX ACCOUNT" where you can sign out of the sandbox account you've been using.