How to connect multiple devices (implement multiple ongoing sessions) using Apple's NearbyInteraction Framework

Question

I'm writing an app that needs to have the functionality of multiple iPhones connecting using Apple's NearbyInteraction framework. I need to have multiple ongoing NISessions to connect multiple iPhones to one another at any particular time. I have been playing around with the sample code for a project that Apple provided, which only implements a program that allows for one session to exist at any particular time. It can be found at: https://developer.apple.com/documentation/nearbyinteraction/implementing_interactions_between_users_in_close_proximity

I am sending the discovery tokens (needed to start each new session) through MultipeerConnectivity, which seems to be working fine. This code below is more or less the code that Apple provided, and works for one session. If I use another iPhone to try to create a second session, I receive the discovery token from the second device (through the MultiPeer connectivity), but then when the second session should simultaneously start, both sessions become invalidated and stop working.

Any chance someone could help guide me in the right direction of how I could adapt this code below to allow for multiple ongoing sessions to connect multiple devices?

func startup() {
    // Create the NISession.
    session = NISession()
    session?.delegate = self

    // Since the session is new, this token has not been shared.
    sharedTokenWithPeer = false

    // If 'connectedPeer' exists, share the discovery token if needed.
    if connectedPeer != nil && mpc != nil {
        if let myToken = session?.discoveryToken {
            print("Initializing...")
            if !sharedTokenWithPeer {
                shareMyDiscoveryToken(token: myToken) 
            }
        } else {
            fatalError("Unable to get self discovery token, is this session invalidated?")
        }
    } else {
        print("Discovering Peer...")
        startupMPC()
        currentDistanceDirectionState = .unknown
    }
}

func session(_ session: NISession, didUpdate nearbyObjects: [NINearbyObject]) {
    guard let peerToken = peerDiscoveryToken else {
        fatalError("don't have peer token")
    }

    // Find the right peer.
    let peerObj = nearbyObjects.first { (obj) -> Bool in
        return obj.discoveryToken == peerToken
    }

    guard let nearbyObjectUpdate = peerObj else {
        return
    }
}

func session(_ session: NISession, didRemove nearbyObjects: [NINearbyObject], reason: NINearbyObject.RemovalReason) {
    guard let peerToken = peerDiscoveryToken else {
        fatalError("don't have peer token")
    }
    // Find the right peer.
    let peerObj = nearbyObjects.first { (obj) -> Bool in
        return obj.discoveryToken == peerToken
    }

    if peerObj == nil {
        return
    }

    switch reason {
    case .peerEnded:
        // Peer stopped communicating, this session is finished, invalidate.
        session.invalidate()

        // Restart the sequence to see if the other side comes back.
        startup()

    case .timeout:

        // Check the configuration is still valid and re-run the session.
        if let config = session.configuration {
            session.run(config)
        }
        print("Peer Timeout")
    default:
        fatalError("Unknown and unhandled NINearbyObject.RemovalReason")
    }
}


// Sharing and receiving discovery token via mpc mechanics

func startupMPC() {
    if mpc == nil {
        // Avoid any simulator instances from finding any actual devices.
        #if targetEnvironment(simulator)
        mpc = MPCSession(service: "nisample", identity: "com.example.apple-samplecode.simulator.peekaboo-nearbyinteraction", maxPeers: 7)
        #else
        mpc = MPCSession(service: "nisample", identity: "com.example.apple-samplecode.peekaboo-nearbyinteraction", maxPeers: 7)
        #endif
        mpc?.peerConnectedHandler = connectedToPeer
        mpc?.peerDataHandler = dataReceivedHandler
        mpc?.peerDisconnectedHandler = disconnectedFromPeer
    }
    mpc?.invalidate()
    mpc?.start()
}

func connectedToPeer(peer: MCPeerID) {
    guard let myToken = session?.discoveryToken else {
        fatalError("Unexpectedly failed to initialize nearby interaction session.")
    }
    print(peer.displayName)
    if connectedPeer.count > 1 {
        //fatalError("Already connected to a peer.")
        print(connectedPeer)
    }

    if !sharedTokenWithPeer {
        shareMyDiscoveryToken(token: myToken)
    }

    connectedPeer.append(peer)
    peerDisplayName = peer.displayName
}

func disconnectedFromPeer(peer: MCPeerID) {
    if connectedPeer.contains(peer) {
        connectedPeer.removeAll(where: {$0 == peer})
        sharedTokenWithPeer = false
    }
}

func dataReceivedHandler(data: Data, peer: MCPeerID) {
    guard let discoveryToken = try? NSKeyedUnarchiver.unarchivedObject(ofClass: NIDiscoveryToken.self, from: data) else {
        fatalError("Unexpectedly failed to decode discovery token.")
    }
    peerDidShareDiscoveryToken(peer: peer, token: discoveryToken)
}

func shareMyDiscoveryToken(token: NIDiscoveryToken) {
    guard let encodedData = try?  NSKeyedArchiver.archivedData(withRootObject: token, requiringSecureCoding: true) else {
        fatalError("Unexpectedly failed to encode discovery token.")
    }
    mpc?.sendDataToAllPeers(data: encodedData)
    sharedTokenWithPeer = true
}

func peerDidShareDiscoveryToken(peer: MCPeerID, token: NIDiscoveryToken) {
    // Create an NI configuration
    peerDiscoveryToken = token

    let config = NINearbyPeerConfiguration(peerToken: token)

    // Run the session
    session?.run(config)
}

Answer 1

Judging by the code excerpt you provided you are only creating 1 NISession. That won't work for more than 1 peer. You need to create an NISession object for each and every peer device. You can store the sessions in a dictionary (they recommend that in the WWDC video). You can use the MCPeerID as a key to identify the peer device. This worked for me.