Ok, ich benutzte gerade von @marsupilami79 mDns4Delphi als Client für Android und Windows.
Leider ist es nicht für IOS implementiert und ich habe keine Ahnung von IOS...
Da ja Bonjour ein first citizen im Apple-Ecosystem ist , hoffe ich mal das irgendwem von uns FMX Entwicklern schon mal ein Bonjour-Client in Delphi über den Weg gelaufen ist...
Kennt ihr einen ?
Es kann sein das es anders heist!
Zeroconf/Bonjour/mDns-sd/multicast DNS Service discovery...usw..

Ich weiß schonmal das es vermutlich das importieren des Frameworks namens "bonjour" (bobjour.dylib) bedarfs...
und das darin ein objekt names "mDNSService" lebt... leider habe ich nie Wrapper entwickelt oder Marshalle benutzt.

ich suche praktisch einen Weg Code unten im Post in FMX Delphi zu übersetzen...
Ich weiß nicht mal ob das swift oder Objective-C ist... und es gibt anscheinend auch noch mehrere Versionen von Swift (5 und 6??).
Wenn ihr auch keine Ahnung habt ist das ok, wenn ihr z.b. mal irgendwas für IOS mit Marshalling gemacht habt und das irgendwie erklären könnt...
Marshalling ist doch das aufrufen von funktionen in diesen .dynlib dateien?

markieren

Code:

        import Foundation
   import Network
   import dnssd
    
   final class BonjourResolver: NSObject, NetServiceDelegate {
    
       typealias CompletionHandler = (Result<(String, Int), Error>) -> Void
    
       @discardableResult
       static func resolve(endpoint: NWEndpoint, completionHandler: @escaping CompletionHandler) -> BonjourResolver {
           dispatchPrecondition(condition: .onQueue(.main))
           let resolver = BonjourResolver(endpoint: endpoint, completionHandler: completionHandler)
           resolver.start()
           return resolver
       }
      
       private init(endpoint: NWEndpoint, completionHandler: @escaping CompletionHandler) {
           self.endpoint = endpoint
           self.completionHandler = completionHandler
       }
      
       deinit {
           // If these fire the last reference to us was released while the resolve
           // was still in flight. That should never happen because we retain
           // ourselves in `start()`.
           assert(self.refQ == nil)
           assert(self.completionHandler == nil)
       }
      
       let endpoint: NWEndpoint
       private var refQ: DNSServiceRef? = nil
       private var completionHandler: (CompletionHandler)? = nil
      
       private func start() {
           dispatchPrecondition(condition: .onQueue(.main))
           precondition(self.refQ == nil)
           precondition(self.completionHandler != nil)
          
           do {
               guard
                   case .service(name: let name, type: let type, domain: let domain, interface: let interface) = self.endpoint,
                   let interfaceIndex = UInt32(exactly: interface?.index ?? 0)
               else {
                   throw NWError.posix(.EINVAL)
               }
    
               let context = Unmanaged.passUnretained(self)
               var refQLocal: DNSServiceRef? = nil
               var err = DNSServiceResolve(
                   &refQLocal,
                   0,
                   interfaceIndex,
                   name, type, domain,
                   { _, _, _, err, _, hostQ, port, _, _, context in
                       // We ignore the &#8216;more coming&#8217; flag because we are a
                       // one-shot operation.
                       let obj = Unmanaged<BonjourResolver>.fromOpaque(context!).takeUnretainedValue()
                       obj.resolveDidComplete(err: err, hostQ: hostQ, port: UInt16(bigEndian: port))
                   }, context.toOpaque())
               guard err == kDNSServiceErr_NoError else {
                   throw NWError.dns(err)
               }
               let ref = refQLocal
    
               err = DNSServiceSetDispatchQueue(ref, .main)
               guard err == kDNSServiceErr_NoError else {
                   DNSServiceRefDeallocate(ref)
                   throw NWError.dns(err)
               }
              
               // The async operation is now started, so we retain ourselves. This
               // is cleaned up when the operation stops in `stop(with:)`.
    
               self.refQ = ref
               _ = context.retain()
           } catch {
               let completionHandler = self.completionHandler
               self.completionHandler = nil
               completionHandler?(.failure(error))
           }
       }
      
       func stop() {
           self.stop(with: .failure(CocoaError(.userCancelled)))
       }
      
       private func stop(with result: Result<(String, Int), Error>) {
           dispatchPrecondition(condition: .onQueue(.main))
    
           if let ref = self.refQ {
               self.refQ = nil
               DNSServiceRefDeallocate(ref)
              
               Unmanaged.passUnretained(self).release()
           }
          
           if let completionHandler = self.completionHandler {
               self.completionHandler = nil
               completionHandler(result)
           }
       }
      
       private func resolveDidComplete(err: DNSServiceErrorType, hostQ: UnsafePointer<CChar>?, port: UInt16) {
           if err == kDNSServiceErr_NoError {
               self.stop(with: .success((String(cString: hostQ!), Int(port))))
           } else {
               self.stop(with: .failure(NWError.dns(err)))
           }
       }
   }

Könnte das für Dich noch funktionieren, ist schon etwas betagt.
https://github.com/deltics/delphi.li...cs.Bonjour.pas

Ich gucke mal...
aber ich fühle mich gerade wie ein google anfänger.

Das MDNS-SD-Anouncing unter Windows und das MDNS-SD discovery unter Android und Windows hat ja mdns4Delphi schon für mich gelöst...
Ich gucke mal ob in dieser library die laut readme file den kompletten Vorgang Kapselt auch service discovery für IOS drin ist.

Aber vielen vielen dank ABER

EDIT:
Leider ist es eine reine Windows VCL Lösung , aber sie ist vollständig in bezug auf textRecords usw.
Wenn also jemand nur mit Windows VCL Services und Windows VCL Clients arbeitet ist das sicher gut.
Aber ich suche einen weg von einem IOS device aus eine Bonjour Query abzusetzten...bzw. einen MDNS request abzusetzen und eine Liste der IP adressen und ports zu bekommen die den von mir gesuchten Service im netzwerk bereitstellen , so wie MDns4Delphi das für Android und Windows kann.
Halt eben nur für IOS.