Caller cannot reconnect without restarting listener in SRTConnection

[noho501]

Question

Hi,

I have a question regarding the reconnect behavior with streamid.

My understanding is that setting a streamid should allow a caller to disconnect and reconnect without needing to restart the listener.
However, in my current implementation, once the caller disconnects, I must stop and restart the listener before the caller can connect again.

Is this the expected behavior, or is there a proper way to configure streamid to allow seamless reconnects?

Background / Tried Steps

URLs used:

Listener:

srt://192.168.2.39:9991?mode=listener&latency=500&streamid=myapp&rcvbuf=8388608&pkt_size=1316&tsbpd=1&sndbuf=8388608

Caller:

srt://192.168.2.39:9991?mode=caller&latency=500&streamid=myapp&rcvbuf=8388608&pkt_size=1316&tsbpd=1&sndbuf=8388608

---

Caller code snippet:

private func startStream() async throws {
    Task.detached(priority: .userInitiated) { [weak self] in
        guard let self else { return }
        try await self.connection.connect(streamURL)
        await self.stream.play()
    }
}

func stopPlayer() async {
    await stream.close()
    await removeAllOutput()
}

After calling stopPlayer(), I am unable to connect again. I must stop and restart the listener before the caller can reconnect.
The only log output when attempting to reconnect is:

18:13:12.342666/ D:SRT.sm: generateSocketID: : @677351440
18:13:22.382021/ D:SRT.sm: generateSocketID: : @677351439

Environment

iPad mini 7 - iOS 26
iPhone 16 Pro - iOS 26
Haishinkit main branch

Could you advise if there is a correct way to allow the caller to reconnect without restarting the listener?

Thank you for your guidance.

[shogo4405]

RTMP works that way, but I thought SRT might behave differently.
In the following table, the “Restrict” column for the SRTO_STREAMID section is set to pre.
https://github.com/Haivision/srt/blob/master/docs/API/API-socket-options.md#list-of-options

I understand that pre means the option must be configured before the connection is established.
So once the connection is established, it can no longer be changed — which matches the behavior I mentioned above.

Of course, it’s possible that I’m misunderstanding the specification, so if you have documentation on this, I’d appreciate it if you could share it.

[noho501]

Hi,

I don’t have official documentation on this matter. However, I performed a few tests using the HaishinKit library as the caller:

• Caller URL:
  srt://192.168.2.39:9991?mode=caller&latency=500&streamid=myapp

• Listener: I also used the Larix app from the AppStore. In Larix, I created a new connection with:
  srt://192.168.2.39:9991 and set the mode to listener.

• When connecting from HaishinKit, I was able to receive video from Larix.

• Notably, even if I stop or terminate the HaishinKit app and then reopen it, I can reconnect successfully to the same listener in Larix.

The code I use to stop the player is:

class SrtPlayback {
    lazy var connection = SRTConnection()
    lazy var stream = SRTStream(connection: connection)
    
    func stopPlayer() async {
        await stream.close()
        await connection.close()
        await removeAllOutput()
    }
}

I also added a debug log:

Task {
    await SRTLogger.shared.setLevel(.debug)
}

From the listener’s perspective, when the caller disconnects, I don’t see any logs or connection status in HaishinKit indicating this, or perhaps the listener has not fully released the previous connection — I’m not entirely sure. I would greatly appreciate any guidance or suggestions on how the listener can detect when a caller disconnects so that reconnects can succeed reliably.

Thank you very much for your time and assistance.

[shogo4405]

So that impression came from Larix’s behavior, I see.

This is due more to HaishinKit’s design than to the SRT specification. SRTConnection is designed so that the remote connection and the local connection have a 1:1 relationship. For that reason, when the remote connection is closed, the local side is also treated as closed.

You can monitor connection and disconnection events by observing SRTConnection.connected.

private var cancellables: Set<AnyCancellable> = []

Task {
  await connection.$connected.sink {
      if $0 == false {
      // Reconnect in listener mode.
      }
    }.store(in: &cancellables)
  }
}

[noho501]

It works. Thank you so much. I truly appreciate it.