When sending media, to avoid expensive copies during a write transaction we
pre-write the file and only do a move during the transaction, which is much
cheaper.
However, the asset.filePath is not safely moveable, it's the path of the cached
asset. So future attempts to send the asset will fail because the underlying
cached file had been moved.
This commit removes the PeerConnectionClient which had become a thin
wrapper between CallService and CallConnection (RingRTC). Now, the
handling is moved mostly to CallConnection and CallService directly
interfaces with it.
Also adds some guards to handle quick call/hangup scenarios on the
caller side. There is also some optimization, in that we try to avoid
sending hangups to the peer if no offer has been sent.
This commit integrates RingRTC in to Signal-iOS. Only two source code
files are affected, CallService.swift and PeerConnection.swift, as well
as the Xcode project. Other code, related to the WebRTC protocol
buffers, has been removed since it is now handled by RingRTC.
RingRTC is provided as a framework named SignalRingRTC.framework. This
works in tandem with WebRTC, and hence currently requires that as well,
WebRTC.framework. To make integration easier, avoid a zombie repository
on GitHub, and keep the integrity of older versions, we re-use the
signal-webrtc-ios-artifacts repository. We simply add the new framework
for SignalRingRTC in the Build directory.
The Xcode project is adjusted to include the new SignalRingRTC
framework. Please note that the WebRTC.framework is also modified for
RingRTC, and is itself updated and part of the delivery. Both of the
framework artifacts come from the ringrtc repository.
The PeerConnectionClient.swift implementation is very different than
the previous version. It now serves as a thin wrapper around the
RingRTC CallConnection class. It provides some fundamental
serialization and helps with overall stability, although it could be
deprecated eventually.
For the CallService, the basic callflow is changed. Previously, it
would use promise chains to go through RTC negotiation until a message
was created for signaling to the peer. Now, RingRTC itself handles
this, and those promise chains are replaced with singular calls in to
the CallConnection (via PeerConnectionClient), with asynchronous
callbacks coming in the future for the signaling parts and other key
notifications.
In summary, other aspects of the integration on CallService include:
- The removal of the call timeout and associated callConnectedPromise.
Timeouts are handled within RingRTC.
- For incoming calls, the 'backgroundTask' is now a variable in the
CallData class and cleared on call connect or eventual deinit.
- When receiving Ice candidates, the existing behavior of queueing them
until the PeerConnectionClient is valid is maintained.
- When sending Ice candidates, the existing behavior of queueing them
so they are sent in batches in cadence with the actual sending speed
is maintained.
- All signaling handlers, to send messages such as offer, answer, etc.,
are handled asynchronously and in a consistent way, with call
failures being issued for any negative result.
