nearby: iOS connection error when advertising

@bourdakos1 This is the code that im using, I also tried to use the code for the example enforcing the connection always to be accepted and failed. I also tried using the hash of the following commit and this did work. Im not sure if its something with a change in the library or something related to the direct accept

 class NCAdvertiser: Connector, AdvertiserDelegate {
     func advertiser(_ advertiser: Advertiser, didReceiveConnectionRequestFrom endpointID: EndpointID, with context: Data, connectionRequestHandler: @escaping (Bool) -> Void) {
         connectionRequestHandler(true)
         // TODO
     }
    
     var advertiser: Advertiser?
    
     init(serviceId: String,
          strategy: String,
          context: UIApplication,
          callbacks: AdvertiserCallbacks,
          userName: String = GeneralConstants.DEFAULT_USERNAME,
          manualAcceptConnections: Bool = false) {
         self.advertiser = nil
          super.init(serviceId: serviceId,
                    strategy: strategy,
                    context: context,
                    callbacks: callbacks,
                    userName: userName,
                    manualAcceptConnections: manualAcceptConnections)
        
         advertiser = Advertiser(connectionManager: connectionManager)
         advertiser!.delegate = self
     }
    
     func startAdvertising() {
         advertiser!.startAdvertising(using: userName)
     }
 }

class Connector: ConnectionManagerDelegate {
    func connectionManager(_ connectionManager: ConnectionManager, didReceive verificationCode: String, from endpointID: EndpointID, verificationHandler: @escaping (Bool) -> Void) {
        verificationHandler(true)
    }
   
    func connectionManager(_ connectionManager: ConnectionManager, didReceive data: Data, withID payloadID: PayloadID, from endpointID: EndpointID) {
        // TODO
    }
   
    func connectionManager(_ connectionManager: ConnectionManager, didReceive stream: InputStream, withID payloadID: PayloadID, from endpointID: EndpointID, cancellationToken token: CancellationToken) {
        // TODO
    }
   
    func connectionManager(_ connectionManager: ConnectionManager, didStartReceivingResourceWithID payloadID: PayloadID, from endpointID: EndpointID, at localURL: URL, withName name: String, cancellationToken token: CancellationToken) {
        // TODO
    }
   
    func connectionManager(_ connectionManager: ConnectionManager, didReceiveTransferUpdate update: TransferUpdate, from endpointID: EndpointID, forPayload payloadID: PayloadID) {
        // TODO
    }
   
    func connectionManager(_ connectionManager: ConnectionManager, didChangeTo state: ConnectionState, for endpointID: EndpointID) {
        switch state {
          case .connecting:
            // Handle connecting state
            break
          case .connected:
            // Handle connected state
            break
          case .disconnected:
            // Handle disconnected state
            // Perform actions when the connection is
            break
          // Your code here
          case .rejected:
            // Handle rejected state
            break
          }
        // TODO
    }
   
    let serviceId: String
    let context: UIApplication
    let callbacks: ConnectionCallbacks
    let userName: Data
    let strategy: Strategy
    let connectionManager: ConnectionManager
    var manualAcceptConnections: Bool

    init(serviceId: String,
         strategy: String,
         context: UIApplication,
         callbacks: ConnectionCallbacks,
         userName: String = GeneralConstants.DEFAULT_USERNAME,
         manualAcceptConnections: Bool = false) {
        self.serviceId = serviceId
        self.context = context
        self.callbacks = callbacks
        self.userName = userName.data(using: .utf8) ?? GeneralConstants.DEFAULT_USERNAME.data(using: .utf8)!
        self.strategy = Connector.getStrategy(strategy)
        self.manualAcceptConnections = manualAcceptConnections
        connectionManager = ConnectionManager(serviceID: serviceId, strategy: self.strategy)
        connectionManager.delegate = self
    }
   
    static func getStrategy(_ strategy: String) -> Strategy {
        guard let connectionStrategy = ConnectionStrategies(rawValue: strategy) else {
            return .star // Default strategy if not found
        }
        switch connectionStrategy {
            case .P2P_CLUSTER:
                return .cluster
            case .P2P_STAR:
                return .star
            case .P2P_POINT_TO_POINT:
            return .pointToPoint
        }
    }
}

@bourdakos1 thanks a lot! This solves the issue

Yes looks like that fixes the issue thanks!

Do you mind trying #1703 and see if that resolves the issue?

@IgVelasco and @DonatoJP thanks for reporting! I am able to reproduce the issue and I’m looking into a fix

Hey!

I am also having problems related to this. But, in my case, it also happens when both devices are configured to follow a “Point to Point” strategy. It seems that it does not depend on the connection strategy selected.

Following the same scenario that @IgVelasco described above, I ALWAYS receive the “libprotobuf ERROR” on the advertiser’s side.

I can also see this, just behind the relevant log described above:

[ERROR] DecodeMessageFromPeer: Failed to verify message.
2023-05-21 19:10:40.851 iOS Example[927/0x16b9cf000] [lvl=2] base_endpoint_channel.cc:158() Read: Read unencrypted KEEP_ALIVE on encrypted channel.

And, in terms of the UI from the example, the advertiser shows the buttons to “Send bytes”, but the discoverer device shows the “Accept/Reject” buttons in a disabled state.