zdk.objc
|
Instance Methods | |
(void) | - onCall:statuschanged: |
Notify upon Call's status change. More... | |
(void) | - onCall:extendedError: |
Notify upon call extended error occurs. More... | |
(void) | - onCall:networkStatistics: |
Event for network statistics update. More... | |
(void) | - onCall:networkQualityLevel:qualityLevel: |
Notify upon network quality level change. More... | |
(void) | - onCall:securityLevelChanged:qualityLevel: |
Notify upon network quality level change. More... | |
(void) | - onCall:dtmfResult: |
Notify upon DTMF call result. More... | |
(void) | - onCall:dtmfReceived: |
Notify upon reception of DTMF from the remote peer. More... | |
(void) | - onCalltransferSucceeded: |
Succesuful call transfer event. More... | |
(void) | - onCall:transferFailure: |
Failed call transfer event. More... | |
(void) | - onCall:transferStarted:number:uri: |
Notify that call transfer is initiated. More... | |
(void) | - onCall:zrtpFailed: |
ZRTP negotiation failed for a call. More... | |
(void) | - onCall:zrtpSuccess:knownPeer:cacheMismatch:peerKnowsUs:sasEncoding:sas:hash:cipher:authTag:keyAgreement: |
ZRTP negotiation succeeded for a call. More... | |
(void) | - onCall:zrtpSecondaryError:error: |
Secondary stream failed to negotiate ZRTP. More... | |
(void) | - onCall:sipHeaderFields: |
SIP header dump for a SIP call. More... | |
(void) | - onVideoOffered: |
Video offered for audio calls. More... | |
(void) | - onVideoStarted:origin: |
Video started. More... | |
(void) | - onVideoStopped:origin: |
Video stopped. More... | |
(void) | - onVideoCameraChanged: |
Video camera changed. More... | |
(void) | - onVideoFormatSelected:dir:width:height:fps: |
Video format selected. More... | |
(NSString *) | - handlesDescription |
Instance Methods inherited from <ZDKEventHandle> | |
(long int) | - eventHandle |
(NSString *) | - handlesDescription |
|
optional |
Reimplemented from <ZDKEventHandle>.
|
optional |
Notify upon reception of DTMF from the remote peer.
The event notify upon DTMF (Dual-Tone Multi-Frequency) reception from the remote peer
[in] | call | The call for which received a DTMF |
[in] | dtmf | The received DTMF |
Notify upon DTMF call result.
The event notify upon DTMF (Dual-Tone Multi-Frequency) result for the call is returned
[in] | call | The call for which DTMF response is returned |
[in] | result | The result |
|
optional |
Notify upon call extended error occurs.
Event fired when extended error in call occurs, providing detailed information for the error in the ExtendedError object.
[in] | call | The call that received the error |
[in] | error | The error object that provides full information regarding the error |
|
optional |
Notify upon network quality level change.
The event notify when network quality level changes
[in] | call | The call which network quality level is changed |
[in] | callChannel | The call's channel |
[in] | qualityLevel | The quality level value |
|
optional |
Event for network statistics update.
The event provides call's network statistic information
[in] | call | The call which network statics is provided |
[in] | networkStatistics | The network statistics object with full statistic information |
|
optional |
Notify upon network quality level change.
The event notify when network quality level changes
[in] | call | The call which network quality level is changed |
[in] | callChannel | The call's channel |
[in] | qualityLevel | The quality level value |
|
optional |
SIP header dump for a SIP call.
Dumps the header of a SIP message from a SIP call. For incoming calls, this is the header of the ZDKNVITE message. For outgoing calls, this is the header of the 200 response.
Each header field from the SIP header is represented as an entry in headerFields
.
Each header field can have one or more values associated with it in the Values
array.
The header field Name
and the Values
are UTF-8 strings.
The structure is valid only for the duration of this callback.
To enable this callback, use zdksipConfig::HeaderDump().
[in] | call | The call |
[in] | headerFields | The header fields array |
|
optional |
Notify upon Call's status change.
Notify upon call's related status information is changed
[in] | call | The call which status is changed |
[in] | status | What status the account is changed to |
|
optional |
Failed call transfer event.
The event notify that the call transfer failed, it also provides the reason for the failure
[in] | call | The call which was transfered failed |
[in] | error | The reason why it failed |
|
optional |
Notify that call transfer is initiated.
The event notify that the call transfer is initiated.The number to transfer to (and display name and optionally an URI, depending on the protocol) is given for informational purposes (or to help make the decision to accept or reject the transfer).
[in] | call | The call on which the transfer request came |
[in] | name | The name of the transfer target |
[in] | number | The number of the transfer target |
[in] | uri | Optionally, protocol dependant URI of the transfer target |
|
optional |
ZRTP negotiation failed for a call.
The ZRTP negotiation for a call has failed. Information about the failure can be found in the error parameter.
[in] | call | The call on which ZRTP failed |
[in] | error | Information on why the ZRTP failed |
|
optional |
Secondary stream failed to negotiate ZRTP.
Multistream ZRTP negotiation has failed for a secondary stream in a call.
ZRTP requires only the first RTP stream in a SIP call to be negotiated with a full Diffie-Hellman key exchange.
Due to the nature of ZRTP the primary RTP stream is an audio stream (to allow for voice confirmation of the SAS).
Subsequent streams in a call, like the video stream for example, will use a shorter version of ZRTP called "Multistream ZRTP" to negotiate the keys.
In case a SIP call is configured with both ZRTP and Video, after the ZRTP finishes securing the audio channel, the SIP call will automatically try to secure the video channel. If this secondary negotiation fails this event will be fired.
This error does NOT mean that the primary channel is suddenly broken. There are no side effects from this failure. The remote end might have a different opinion on the matter and might decide to close the call.
[in] | call | The call Id on which the secondary ZRTP negotiation failed |
[in] | callChannel | The type of the secondary RTP stream (usually video) |
[in] | error | Detailed error information about the failure |
|
optional |
ZRTP negotiation succeeded for a call.
The ZRTP negotiation for a call has succeeded. This does not always mean full security yet, due to the nature of ZRTP. Even though at this stage there is an active SRTP encryption, the keys used might be compromised.
To make sure the keys were safe the participants will need to do verbal comparison of a short string derived from the same calculations. In case the identify of the participants was confirmed by using secret data from previous calls SAS verification is not required.
If the peer in this call was known (found in the cache) the knownPeer
parameter will be set to 1. If we meet this peer for the first time, the parameter will be set to 0.
If the peer knows us, the peerKnowsUs
parameter will be set to 1. If the peer sees us for the first time, or they see some other problem with our identity, this flag will be set to 0.
Note that this information comes over the encrypted channel protected by ZRTP but there is a small chance the encryption was compromised (i.e. do not completely trust this flag).
If the peer is known and we agree on the retained secrets in our caches (both us and them), the cacheMismatch will be set to 0.
If the peer was known but we disagree on the retained secret there might be a security problem or one of us might have a corrupted cache file. In this case the cacheMismatch will be set to 1.
If the peer is not known, the cacheMismatch
value is set to 1 to make it easier to check if we need SAS comparison by only looking at one parameter instead of making complex logic checks.
If the peer sent us an indication that they do not know us from previous calls (peerKnowsUs
set to 0), cacheMismatch
will also be set to 1 to force SAS verification.
The string that needs to be compared is called the Short Authentication String. It is returned in the sas
parameter. Although sas
is based on a binary hash, it is encoded in a human-readable form. The encoding type is returned in the sasEncoding
paramter.
The ZRTP RFC recommends using the following warning text if SAS comparison is required for a known peer (i.e. when knownPeer
is 1 but cacheMismatch
is also set to 1):
Long version: We expected the other party to have a shared secret cached from a previous call, but they don't have it. This may mean your peer simply lost their cache of shared secrets, but it could also mean someone is trying to wiretap you. To resolve this question you must check the authentication string with your peer. If it doesn't match, it indicates the presence of a wiretapper.
Short version: Something's wrong. You must check the authentication string with your peer. If it doesn't match, it indicates the presence of a wiretapper.
Even if knownPeer
is 1 and cacheMismatch
is 0 and peerKnowsUs
is 1, the SAS should be made available on demand from the user. If the user demands SAS verification and it fails,the call will be treated as insecure and the user will be alerted.
More information about the ZRTP negotiation is returned in the rest of the parameters.
"cipher" and "authTag" are of interest as they'll be employed by the SRTP encryption and it might be useful to display them somewhere.
"hash" and "keyAgreement" are the hash algorithm and the key agreement method used in this call.
[in] | call | The call |
[in] | zidHex | The peer's ZRTP ID (ZID) in HEX representation |
[in] | knownPeer | 1 if the peer is known, 0 if we see them for the first time |
[in] | cacheMismatch | 1 if the peer needs to be confirmed, 0 if the cache agrees |
[in] | peerKnowsUs | 1 if the peer knows us, 0 if they see us for the first time or if they have encountered a cache mismatch of their own |
[in] | sasEncoding | The SAS encoding |
[in] | sas | The Short Authentication String to be confirmed if needed. The string is in human readable form in the encoding sasEncoding |
[in] | hash | The chosen Hash Algorithm |
[in] | cipher | The chosen Cipher Algorithm (used in SRTP) |
[in] | authTag | The chosen Authentication Tag type (used in SRTP) |
[in] | keyAgreement | The key agreement method used for the negotiation |
|
optional |
Succesuful call transfer event.
The event notify upon the call transfer has succeeded
[in] | call | The call which was transfered |
|
optional |
|
optional |
Video format selected.
[in] | call | The call for which the video format was selected |
[in] | dir | The direction |
[in] | width | Width in pixels |
[in] | height | Height in pixels |
[in] | fps | Frames per seconds |
|
optional |
Video offered for audio calls.
The remote party has offered us video during a normal (audio) call. Use acceptVideo() to accept or decline the video
[in] | call | The call |
|
optional |
Video started.
The video has started.The call is ready to encode and send frames over the network. Use the sendVideoFrame() function to send frames.
[in] | call | The video call |
[in] | origin | The call initiator type (incoming, outgoing) |
|
optional |
Video stopped.
The Video has stopped.
[in] | call | The video call |
[in] | origin | The call initiator type (incoming, outgoing) |