Liblinphone  3.10.2
Defines | Typedefs | Enumerations | Functions
Placing and receiving calls

Defines

#define linphone_call_params_local_conference_mode   linphone_call_params_get_local_conference_mode

Typedefs

typedef enum
_LinphoneMediaDirection 
LinphoneMediaDirection
typedef struct _LinphoneCallParams LinphoneCallParams
typedef struct _LinphoneConference LinphoneConference
typedef struct
_LinphoneCorferenceParams 
LinphoneConferenceParams
typedef struct _LinphoneCall LinphoneCall
typedef enum _LinphonePrivacy LinphonePrivacy
typedef struct _LinphonePlayer LinphonePlayer
typedef void(* LinphonePlayerEofCallback )(struct _LinphonePlayer *obj, void *user_data)
typedef enum _LinphoneCallState LinphoneCallState
typedef enum _LinphoneAudioRoute LinphoneAudioRoute

Enumerations

enum  _LinphoneMediaDirection {
  LinphoneMediaDirectionInvalid = -1,
  LinphoneMediaDirectionInactive,
  LinphoneMediaDirectionSendOnly,
  LinphoneMediaDirectionRecvOnly,
  LinphoneMediaDirectionSendRecv
}
enum  _LinphonePrivacy {
  LinphonePrivacyNone = 0x0,
  LinphonePrivacyUser = 0x1,
  LinphonePrivacyHeader = 0x2,
  LinphonePrivacySession = 0x4,
  LinphonePrivacyId = 0x8,
  LinphonePrivacyCritical = 0x10,
  LinphonePrivacyDefault = 0x8000
}
enum  _LinphoneCallState {
  LinphoneCallIdle,
  LinphoneCallIncomingReceived,
  LinphoneCallOutgoingInit,
  LinphoneCallOutgoingProgress,
  LinphoneCallOutgoingRinging,
  LinphoneCallOutgoingEarlyMedia,
  LinphoneCallConnected,
  LinphoneCallStreamsRunning,
  LinphoneCallPausing,
  LinphoneCallPaused,
  LinphoneCallResuming,
  LinphoneCallRefered,
  LinphoneCallError,
  LinphoneCallEnd,
  LinphoneCallPausedByRemote,
  LinphoneCallUpdatedByRemote,
  LinphoneCallIncomingEarlyMedia,
  LinphoneCallUpdating,
  LinphoneCallReleased,
  LinphoneCallEarlyUpdatedByRemote,
  LinphoneCallEarlyUpdating
}
enum  _LinphoneAudioRoute {
  LinphoneAudioRouteEarpiece = MSAudioRouteEarpiece,
  LinphoneAudioRouteSpeaker = MSAudioRouteSpeaker
}

Functions

void linphone_call_params_add_custom_header (LinphoneCallParams *cp, const char *header_name, const char *header_value)
LinphoneCallParamslinphone_call_params_copy (const LinphoneCallParams *cp)
bool_t linphone_call_params_early_media_sending_enabled (const LinphoneCallParams *cp)
void linphone_call_params_enable_early_media_sending (LinphoneCallParams *cp, bool_t enabled)
void linphone_call_params_enable_low_bandwidth (LinphoneCallParams *cp, bool_t enabled)
void linphone_call_params_enable_audio (LinphoneCallParams *cp, bool_t enabled)
void linphone_call_params_enable_video (LinphoneCallParams *cp, bool_t enabled)
const char * linphone_call_params_get_custom_header (const LinphoneCallParams *cp, const char *header_name)
bool_t linphone_call_params_get_local_conference_mode (const LinphoneCallParams *cp)
LinphoneMediaEncryption linphone_call_params_get_media_encryption (const LinphoneCallParams *cp)
LinphonePrivacyMask linphone_call_params_get_privacy (const LinphoneCallParams *cp)
float linphone_call_params_get_received_framerate (const LinphoneCallParams *cp)
MSVideoSize linphone_call_params_get_received_video_size (const LinphoneCallParams *cp)
const char * linphone_call_params_get_record_file (const LinphoneCallParams *cp)
const char * linphone_call_params_get_rtp_profile (const LinphoneCallParams *cp)
float linphone_call_params_get_sent_framerate (const LinphoneCallParams *cp)
MSVideoSize linphone_call_params_get_sent_video_size (const LinphoneCallParams *cp)
const char * linphone_call_params_get_session_name (const LinphoneCallParams *cp)
const LinphonePayloadTypelinphone_call_params_get_used_audio_codec (const LinphoneCallParams *cp)
const LinphonePayloadTypelinphone_call_params_get_used_video_codec (const LinphoneCallParams *cp)
const LinphonePayloadTypelinphone_call_params_get_used_text_codec (const LinphoneCallParams *cp)
bool_t linphone_call_params_low_bandwidth_enabled (const LinphoneCallParams *cp)
void linphone_call_params_set_audio_bandwidth_limit (LinphoneCallParams *cp, int bw)
void linphone_call_params_set_media_encryption (LinphoneCallParams *cp, LinphoneMediaEncryption enc)
void linphone_call_params_set_privacy (LinphoneCallParams *cp, LinphonePrivacyMask privacy)
void linphone_call_params_set_record_file (LinphoneCallParams *cp, const char *path)
void linphone_call_params_set_session_name (LinphoneCallParams *cp, const char *name)
bool_t linphone_call_params_audio_enabled (const LinphoneCallParams *cp)
bool_t linphone_call_params_video_enabled (const LinphoneCallParams *cp)
LinphoneMediaDirection linphone_call_params_get_audio_direction (const LinphoneCallParams *cp)
LinphoneMediaDirection linphone_call_params_get_video_direction (const LinphoneCallParams *cp)
void linphone_call_params_set_audio_direction (LinphoneCallParams *cp, LinphoneMediaDirection dir)
void linphone_call_params_set_video_direction (LinphoneCallParams *cp, LinphoneMediaDirection dir)
void * linphone_call_params_get_user_data (const LinphoneCallParams *cp)
void linphone_call_params_set_user_data (LinphoneCallParams *cp, void *ud)
LinphoneCallParamslinphone_call_params_ref (LinphoneCallParams *cp)
void linphone_call_params_unref (LinphoneCallParams *cp)
void linphone_call_params_destroy (LinphoneCallParams *cp)
LinphoneConferenceParamslinphone_conference_params_new (const LinphoneCore *core)
void linphone_conference_params_free (LinphoneConferenceParams *params)
LinphoneConferenceParamslinphone_conference_params_clone (const LinphoneConferenceParams *params)
void linphone_conference_params_enable_video (LinphoneConferenceParams *params, bool_t enable)
bool_t linphone_conference_params_video_requested (const LinphoneConferenceParams *params)
int linphone_conference_remove_participant (LinphoneConference *obj, const LinphoneAddress *uri)
bctbx_list_t * linphone_conference_get_participants (const LinphoneConference *obj)
bool_t linphone_call_get_authentication_token_verified (LinphoneCall *call)
void linphone_call_set_authentication_token_verified (LinphoneCall *call, bool_t verified)
LinphoneCalllinphone_call_ref (LinphoneCall *obj)
void linphone_call_unref (LinphoneCall *obj)
const LinphoneCallParamslinphone_call_get_current_params (LinphoneCall *call)
const LinphoneCallParamslinphone_call_get_remote_params (LinphoneCall *call)
const LinphoneAddresslinphone_call_get_remote_address (const LinphoneCall *call)
char * linphone_call_get_remote_address_as_string (const LinphoneCall *call)
LinphoneCallState linphone_call_get_state (const LinphoneCall *call)
LinphoneReason linphone_call_get_reason (const LinphoneCall *call)
const LinphoneErrorInfolinphone_call_get_error_info (const LinphoneCall *call)
void * linphone_call_get_user_data (const LinphoneCall *call)
void linphone_call_set_user_data (LinphoneCall *call, void *user_pointer)
LinphoneCallLoglinphone_call_get_call_log (const LinphoneCall *call)
const char * linphone_call_get_refer_to (const LinphoneCall *call)
LinphoneCalllinphone_call_get_transferer_call (const LinphoneCall *call)
LinphoneCalllinphone_call_get_transfer_target_call (const LinphoneCall *call)
LinphoneCallDir linphone_call_get_dir (const LinphoneCall *call)
const char * linphone_call_get_remote_user_agent (LinphoneCall *call)
const char * linphone_call_get_remote_contact (LinphoneCall *call)
bool_t linphone_call_has_transfer_pending (const LinphoneCall *call)
int linphone_call_get_duration (const LinphoneCall *call)
LinphoneCalllinphone_call_get_replaced_call (LinphoneCall *call)
void linphone_call_enable_camera (LinphoneCall *call, bool_t enable)
void linphone_call_send_vfu_request (LinphoneCall *call)
int linphone_call_take_video_snapshot (LinphoneCall *call, const char *file)
int linphone_call_take_preview_snapshot (LinphoneCall *call, const char *file)
bool_t linphone_call_camera_enabled (const LinphoneCall *call)
const char * linphone_privacy_to_string (LinphonePrivacy privacy)
LinphoneCalllinphone_core_invite (LinphoneCore *lc, const char *url)
LinphoneCalllinphone_core_invite_with_params (LinphoneCore *lc, const char *url, const LinphoneCallParams *p)
LinphoneCalllinphone_core_invite_address (LinphoneCore *lc, const LinphoneAddress *addr)
int linphone_core_transfer_call (LinphoneCore *lc, LinphoneCall *call, const char *url)
int linphone_core_transfer_call_to_another (LinphoneCore *lc, LinphoneCall *call, LinphoneCall *dest)
int linphone_core_accept_early_media_with_params (LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params)
int linphone_core_accept_early_media (LinphoneCore *lc, LinphoneCall *call)
int linphone_core_update_call (LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params)
int linphone_core_defer_call_update (LinphoneCore *lc, LinphoneCall *call)
int linphone_core_accept_call_update (LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params)
int linphone_core_accept_call (LinphoneCore *lc, LinphoneCall *call)
int linphone_core_accept_call_with_params (LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params)
int linphone_core_terminate_call (LinphoneCore *lc, LinphoneCall *the_call)
int linphone_core_decline_call (LinphoneCore *lc, LinphoneCall *call, LinphoneReason reason)
int linphone_core_terminate_all_calls (LinphoneCore *lc)
const bctbx_list_t * linphone_core_get_calls (LinphoneCore *lc)
bool_t linphone_core_in_call (const LinphoneCore *lc)
LinphoneCalllinphone_core_get_current_call (const LinphoneCore *lc)
int linphone_core_pause_call (LinphoneCore *lc, LinphoneCall *call)
int linphone_core_pause_all_calls (LinphoneCore *lc)
int linphone_core_resume_call (LinphoneCore *lc, LinphoneCall *call)
LinphoneCalllinphone_core_get_call_by_remote_address (LinphoneCore *lc, const char *remote_address)
void linphone_core_set_inc_timeout (LinphoneCore *lc, int seconds)
int linphone_core_get_inc_timeout (LinphoneCore *lc)
void linphone_core_set_in_call_timeout (LinphoneCore *lc, int seconds)
int linphone_core_get_in_call_timeout (LinphoneCore *lc)
int linphone_core_get_delayed_timeout (LinphoneCore *lc)
void linphone_core_set_delayed_timeout (LinphoneCore *lc, int seconds)
int linphone_core_get_calls_nb (const LinphoneCore *lc)
bool_t linphone_core_can_we_add_call (LinphoneCore *lc)
LinphoneCallParamslinphone_core_create_call_params (LinphoneCore *lc, LinphoneCall *call)
bool_t linphone_core_sound_resources_locked (LinphoneCore *lc)
LinphoneCorelinphone_call_get_core (const LinphoneCall *call)
const LinphoneAddresslinphone_core_get_current_call_remote_address (LinphoneCore *lc)
int linphone_call_send_dtmf (LinphoneCall *call, char dtmf)
int linphone_call_send_dtmfs (LinphoneCall *call, char *dtmfs)
void linphone_call_cancel_dtmfs (LinphoneCall *call)
MS2_DEPRECATED bool_t linphone_call_is_in_conference (const LinphoneCall *call)
LinphoneConferencelinphone_call_get_conference (const LinphoneCall *call)
void linphone_call_set_audio_route (LinphoneCall *call, LinphoneAudioRoute route)
LinphoneCalllinphone_core_invite_address_with_params (LinphoneCore *lc, const LinphoneAddress *addr, const LinphoneCallParams *params)
bool_t linphone_core_is_incoming_invite_pending (LinphoneCore *lc)
int linphone_core_redirect_call (LinphoneCore *lc, LinphoneCall *call, const char *redirect_uri)
LinphoneCalllinphone_core_get_call_by_remote_address2 (LinphoneCore *lc, const LinphoneAddress *remote_address)
LinphoneCalllinphone_core_find_call_from_uri (const LinphoneCore *lc, const char *uri)
LinphoneConferencelinphone_core_create_conference_with_params (LinphoneCore *lc, const LinphoneConferenceParams *params)
int linphone_core_add_to_conference (LinphoneCore *lc, LinphoneCall *call)
int linphone_core_add_all_to_conference (LinphoneCore *lc)
int linphone_core_remove_from_conference (LinphoneCore *lc, LinphoneCall *call)
bool_t linphone_core_is_in_conference (const LinphoneCore *lc)
int linphone_core_enter_conference (LinphoneCore *lc)
int linphone_core_leave_conference (LinphoneCore *lc)
float linphone_core_get_conference_local_input_volume (LinphoneCore *lc)
int linphone_core_terminate_conference (LinphoneCore *lc)
int linphone_core_get_conference_size (LinphoneCore *lc)
int linphone_core_start_conference_recording (LinphoneCore *lc, const char *path)
int linphone_core_stop_conference_recording (LinphoneCore *lc)
LinphoneConferencelinphone_core_get_conference (LinphoneCore *lc)

Detailed Description

The LinphoneCall object represents an incoming or outgoing call managed by the LinphoneCore. Outgoing calls can be created using linphone_core_invite() or linphone_core_invite_address(), while incoming calls are notified to the application through the LinphoneCoreVTable::call_state_changed callback.

See the basic call tutorial.


Define Documentation


Typedef Documentation

Enum describing type of audio route.

typedef struct _LinphoneCall LinphoneCall

The LinphoneCall object represents a call issued or received by the LinphoneCore

The LinphoneCallParams is an object containing various call related parameters. It can be used to retrieve parameters from a currently running call or modify the call's characteristics dynamically.

LinphoneCallState enum represents the different state a call can reach into. The application is notified of state changes through the LinphoneCoreVTable::call_state_changed callback.

typedef struct _LinphoneConference LinphoneConference

LinphoneConference class

typedef struct _LinphoneCorferenceParams LinphoneConferenceParams

Parameters for initialization of conferences

Typedef for enum

Player interface.

typedef void(* LinphonePlayerEofCallback)(struct _LinphonePlayer *obj, void *user_data)

Callback for notifying end of play (file).

Parameters:
objthe LinphonePlayer
user_datathe user_data provided when calling linphone_player_open().

Defines privacy policy to apply as described by rfc3323


Enumeration Type Documentation

Enum describing type of audio route.

LinphoneCallState enum represents the different state a call can reach into. The application is notified of state changes through the LinphoneCoreVTable::call_state_changed callback.

Enumerator:
LinphoneCallIdle 

Initial call state

LinphoneCallIncomingReceived 

This is a new incoming call

LinphoneCallOutgoingInit 

An outgoing call is started

LinphoneCallOutgoingProgress 

An outgoing call is in progress

LinphoneCallOutgoingRinging 

An outgoing call is ringing at remote end

LinphoneCallOutgoingEarlyMedia 

An outgoing call is proposed early media

LinphoneCallConnected 

Connected, the call is answered

LinphoneCallStreamsRunning 

The media streams are established and running

LinphoneCallPausing 

The call is pausing at the initiative of local end

LinphoneCallPaused 

The call is paused, remote end has accepted the pause

LinphoneCallResuming 

The call is being resumed by local end

LinphoneCallRefered 

The call is being transfered to another party, resulting in a new outgoing call to follow immediately

LinphoneCallError 

The call encountered an error

LinphoneCallEnd 

The call ended normally

LinphoneCallPausedByRemote 

The call is paused by remote end

LinphoneCallUpdatedByRemote 

The call's parameters change is requested by remote end, used for example when video is added by remote

LinphoneCallIncomingEarlyMedia 

We are proposing early media to an incoming call

LinphoneCallUpdating 

A call update has been initiated by us

LinphoneCallReleased 

The call object is no more retained by the core

Indicates for a given media the stream direction

Enumerator:
LinphoneMediaDirectionSendOnly 

No active media not supported yet

LinphoneMediaDirectionRecvOnly 

Send only mode

LinphoneMediaDirectionSendRecv 

recv only mode

Defines privacy policy to apply as described by rfc3323

Enumerator:
LinphonePrivacyNone 

Privacy services must not perform any privacy function

LinphonePrivacyUser 

Request that privacy services provide a user-level privacy function. With this mode, "from" header is hidden, usually replaced by From: "Anonymous" <sip:anonymous@anonymous.invalid>

LinphonePrivacyHeader 

Request that privacy services modify headers that cannot be set arbitrarily by the user (Contact/Via).

LinphonePrivacySession 

Request that privacy services provide privacy for session media

LinphonePrivacyId 

rfc3325 The presence of this privacy type in a Privacy header field indicates that the user would like the Network Asserted Identity to be kept private with respect to SIP entities outside the Trust Domain with which the user authenticated. Note that a user requesting multiple types of privacy MUST include all of the requested privacy types in its Privacy header field value

LinphonePrivacyCritical 

Privacy service must perform the specified services or fail the request

LinphonePrivacyDefault 

Special keyword to use privacy as defined either globally or by proxy using linphone_proxy_config_set_privacy()


Function Documentation

bool_t linphone_call_camera_enabled ( const LinphoneCall call)

Returns TRUE if camera pictures are allowed to be sent to the remote party.

Stop current DTMF sequence sending.

Please note that some DTMF could be already sent, depending on when this function call is delayed from linphone_call_send_dtmfs. This function will be automatically called if call state change to anything but LinphoneCallStreamsRunning.

Parameters:
callThe LinphoneCall object
void linphone_call_enable_camera ( LinphoneCall call,
bool_t  enable 
)

Indicate whether camera input should be sent to remote end.

Returns whether ZRTP authentication token is verified. If not, it must be verified by users as described in ZRTP procedure. Once done, the application must inform of the results with linphone_call_set_authentication_token_verified().

Parameters:
callthe LinphoneCall
Returns:
TRUE if authentication token is verifed, false otherwise.

Returns the call log associated to this call.

Return the associated conference object

Parameters:
callLinphoneCall
Returns:
A pointer on LinphoneConference or NULL if the call is not part of any conference.

Get the core that has created the specified call.

Parameters:
[in]callLinphoneCall object
Returns:
The LinphoneCore object that has created the specified call.

Returns current parameters associated to the call.

Returns direction of the call (incoming or outgoing).

Returns call's duration in seconds.

Returns full details about call errors or termination reasons.

Returns the reason for a call termination (either error or normal termination)

const char* linphone_call_get_refer_to ( const LinphoneCall call)

Returns the refer-to uri (if the call was transfered).

Returns the remote address associated to this call

Returns the remote address associated to this call as a string.

The result string must be freed by user using ms_free().

Returns the far end's sip contact as a string, if available.

Returns call parameters proposed by remote.

This is useful when receiving an incoming call, to know whether the remote party supports video, encryption or whatever.

Returns the far end's user agent description string, if available.

Returns the call object this call is replacing, if any. Call replacement can occur during call transfers. By default, the core automatically terminates the replaced call and accept the new one. This function allows the application to know whether a new incoming call is a one that replaces another one.

Retrieves the call's current state.

When this call has received a transfer request, returns the new call that was automatically created as a result of the transfer.

Returns the transferer if this call was started automatically as a result of an incoming transfer request. The call in which the transfer request was received is returned in this case.

void * linphone_call_get_user_data ( const LinphoneCall call)

Retrieve the user pointer associated with the call.

Parameters:
[in]callThe call.
Returns:
The user pointer associated with the call.

Returns true if this calls has received a transfer that has not been executed yet. Pending transfers are executed when this call is being paused or closed, locally or by remote endpoint. If the call is already paused while receiving the transfer request, the transfer immediately occurs.

MS2_DEPRECATED bool_t linphone_call_is_in_conference ( const LinphoneCall call)

Return TRUE if this call is currently part of a conference

Parameters:
callLinphoneCall
Returns:
TRUE if part of a conference.
Deprecated:
Use linphone_call_get_conference() instead.
void linphone_call_params_add_custom_header ( LinphoneCallParams cp,
const char *  header_name,
const char *  header_value 
)

Add a custom SIP header in the INVITE for a call.

Parameters:
[in]cpThe LinphoneCallParams to add a custom SIP header to.
[in]header_nameThe name of the header to add.
[in]header_valueThe content of the header to add.

Tell whether audio is enabled or not.

Parameters:
[in]cpLinphoneCallParams object
Returns:
A boolean value telling whether audio is enabled or not.

Copy an existing LinphoneCallParams object to a new LinphoneCallParams object.

Parameters:
[in]cpThe LinphoneCallParams object to copy.
Returns:
A copy of the LinphoneCallParams object.

Destroy a LinphoneCallParams object.

Parameters:
[in]cpLinphoneCallParams object
Deprecated:
Use linphone_call_params_unref() instead.

Indicate whether sending of early media was enabled.

Parameters:
[in]cpLinphoneCallParams object
Returns:
A boolean value telling whether sending of early media was enabled.
void linphone_call_params_enable_audio ( LinphoneCallParams cp,
bool_t  enabled 
)

Enable audio stream.

Parameters:
[in]cpLinphoneCallParams object
[in]enabledA boolean value telling whether to enable audio or not.

Enable sending of real early media (during outgoing calls).

Parameters:
[in]cpLinphoneCallParams object
[in]enabledA boolean value telling whether to enable early media sending or not.

Indicate low bandwith mode. Configuring a call to low bandwidth mode will result in the core to activate several settings for the call in order to ensure that bitrate usage is lowered to the minimum possible. Typically, ptime (packetization time) will be increased, audio codec's output bitrate will be targetted to 20kbit/s provided that it is achievable by the codec selected after SDP handshake. Video is automatically disabled.

Parameters:
[in]cpLinphoneCallParams object
[in]enabledA boolean value telling whether to activate the low bandwidth mode or not.
void linphone_call_params_enable_video ( LinphoneCallParams cp,
bool_t  enabled 
)

Enable video stream.

Parameters:
[in]cpLinphoneCallParams object
[in]enabledA boolean value telling whether to enable video or not.

Get the audio stream direction.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The audio stream direction associated with the call params.
const char* linphone_call_params_get_custom_header ( const LinphoneCallParams cp,
const char *  header_name 
)

Get a custom SIP header.

Parameters:
[in]cpThe LinphoneCallParams to get the custom SIP header from.
[in]header_nameThe name of the header to get.
Returns:
The content of the header or NULL if not found.

Tell whether the call is part of the locally managed conference.

Warning:
If a conference server is used to manage conferences, that function does not return TRUE even if the conference is running.
If you want to test whether the conference is running, you should test whether linphone_core_get_conference() return a non-null pointer.
Parameters:
[in]cpLinphoneCallParams object
Returns:
A boolean value telling whether the call is part of the locally managed conference.

Get the kind of media encryption selected for the call.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The kind of media encryption selected for the call.
LinphonePrivacyMask linphone_call_params_get_privacy ( const LinphoneCallParams cp)

Get requested level of privacy for the call.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The privacy mode used for the call.

Get the framerate of the video that is received.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The actual received framerate in frames per seconds, 0 if not available.

Get the size of the video that is received.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The received video size or MS_VIDEO_SIZE_UNKNOWN if not available.

Get the path for the audio recording of the call.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The path to the audio recording of the call.

Get the RTP profile being used.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The RTP profile.

Get the framerate of the video that is sent.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The actual sent framerate in frames per seconds, 0 if not available.

Gets the size of the video that is sent.

Parameters:
[in]cpLinphoneCalParams object
Returns:
The sent video size or MS_VIDEO_SIZE_UNKNOWN if not available.

Get the session name of the media session (ie in SDP). Subject from the SIP message can be retrieved using linphone_call_params_get_custom_header() and is different.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The session name of the media session.

Get the audio codec used in the call, described as a LinphonePayloadType object.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The LinphonePayloadType object corresponding to the audio codec being used in the call.

Get the text codec used in the call, described as a LinphonePayloadType structure.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The LinphonePayloadType object corresponding to the text codec being used in the call.

Get the video codec used in the call, described as a LinphonePayloadType structure.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The LinphonePayloadType object corresponding to the video codec being used in the call.

Get the user data associated with the call params.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The user data associated with the call params.

Get the video stream direction.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The video stream direction associated with the call params.

Tell whether the call has been configured in low bandwidth mode or not. This mode can be automatically discovered thanks to a stun server when activate_edge_workarounds=1 in section [net] of configuration file. An application that would have reliable way to know network capacity may not use activate_edge_workarounds=1 but instead manually configure low bandwidth mode with linphone_call_params_enable_low_bandwidth(). When enabled, this param may transform a call request with video in audio only mode.

Parameters:
[in]cpLinphoneCallParams object
Returns:
A boolean value telling whether the low bandwidth mode has been configured/detected.

Acquire a reference to the call params.

Parameters:
[in]cpLinphoneCallParams object
Returns:
The same LinphoneCallParams object

Refine bandwidth settings for this call by setting a bandwidth limit for audio streams. As a consequence, codecs whose bitrates are not compatible with this limit won't be used.

Parameters:
[in]cpLinphoneCallParams object
[in]bwThe audio bandwidth limit to set in kbit/s.

Set the audio stream direction.

Parameters:
[in]cpLinphoneCallParams object
[in]dirThe audio stream direction associated with this call params.

Set requested media encryption for a call.

Parameters:
[in]cpLinphoneCallParams object
[in]encThe media encryption to use for the call.
void linphone_call_params_set_privacy ( LinphoneCallParams cp,
LinphonePrivacyMask  privacy 
)

Set requested level of privacy for the call.

Parameters:
[in]cpLinphoneCallParams object
[in]privacyThe privacy mode to used for the call.
void linphone_call_params_set_record_file ( LinphoneCallParams cp,
const char *  path 
)

Enable recording of the call. This function must be used before the call parameters are assigned to the call. The call recording can be started and paused after the call is established with linphone_call_start_recording() and linphone_call_pause_recording().

Parameters:
[in]cpLinphoneCallParams object
[in]pathA string containing the path and filename of the file where audio/video streams are to be written. The filename must have either .mkv or .wav extention. The video stream will be written only if a MKV file is given.
void linphone_call_params_set_session_name ( LinphoneCallParams cp,
const char *  name 
)

Set the session name of the media session (ie in SDP). Subject from the SIP message (which is different) can be set using linphone_call_params_set_custom_header().

Parameters:
[in]cpLinphoneCallParams object
[in]nameThe session name to be used.

Assign a user data to the call params.

Parameters:
[in]cpLinphoneCallParams object
[in]udThe user data to associate with the call params.

Set the video stream direction.

Parameters:
[in]cpLinphoneCallParams object
[in]dirThe video stream direction associated with this call params.

Release a reference to the call params.

Parameters:
[in]cpLinphoneCallParams object

Tell whether video is enabled or not.

Parameters:
[in]cpLinphoneCallParams object
Returns:
A boolean value telling whether video is enabled or not.

Acquire a reference to the call. An application that wishes to retain a pointer to call object must use this function to unsure the pointer remains valid. Once the application no more needs this pointer, it must call linphone_call_unref().

Parameters:
[in]callThe call.
Returns:
The same call.
int linphone_call_send_dtmf ( LinphoneCall call,
char  dtmf 
)

Send the specified dtmf.

The dtmf is automatically played to the user.

Parameters:
callThe LinphoneCall object
dtmfThe dtmf name specified as a char, such as '0', '#' etc...
Returns:
0 if successful, -1 on error.
int linphone_call_send_dtmfs ( LinphoneCall call,
char *  dtmfs 
)

Send a list of dtmf.

The dtmfs are automatically sent to remote, separated by some needed customizable delay. Sending is canceled if the call state changes to something not LinphoneCallStreamsRunning.

Parameters:
callThe LinphoneCall object
dtmfsA dtmf sequence such as '123#123123'
Returns:
-2 if there is already a DTMF sequence, -1 if call is not ready, 0 otherwise.

Request remote side to send us a Video Fast Update.

Change the playback output device (currently only used for blackberry)

Parameters:
call
routethe wanted audio route (earpiece, speaker, ...)
void linphone_call_set_authentication_token_verified ( LinphoneCall call,
bool_t  verified 
)

Set the result of ZRTP short code verification by user. If remote party also does the same, it will update the ZRTP cache so that user's verification will not be required for the two users.

Parameters:
callthe LinphoneCall
verifiedwhether the ZRTP SAS is verified.
void linphone_call_set_user_data ( LinphoneCall call,
void *  ud 
)

Assign a user pointer to the call.

Parameters:
[in]callThe call.
[in]udThe user pointer to associate with the call.
int linphone_call_take_preview_snapshot ( LinphoneCall call,
const char *  file 
)

Take a photo of currently captured video and write it into a jpeg file. Note that the snapshot is asynchronous, an application shall not assume that the file is created when the function returns.

Parameters:
calla LinphoneCall
filea path where to write the jpeg content.
Returns:
0 if successfull, -1 otherwise (typically if jpeg format is not supported).
int linphone_call_take_video_snapshot ( LinphoneCall call,
const char *  file 
)

Take a photo of currently received video and write it into a jpeg file. Note that the snapshot is asynchronous, an application shall not assume that the file is created when the function returns.

Parameters:
calla LinphoneCall
filea path where to write the jpeg content.
Returns:
0 if successfull, -1 otherwise (typically if jpeg format is not supported).

Release reference to the call.

Parameters:
[in]callThe call.

Get URIs of all participants of one conference The returned bctbx_list_t contains URIs of all participant. That list must be freed after use and each URI must be unref with linphone_address_unref()

Parameters:
objA LinphoneConference
Returns:
A list of LinphoneAddress objects.

Clone a LinphoneConferenceParams

Parameters:
paramsThe LinphoneConferenceParams to clone
Returns:
An allocated LinphoneConferenceParams with the same parameters than params
void linphone_conference_params_enable_video ( LinphoneConferenceParams params,
bool_t  enable 
)

Enable video when starting a conference

Parameters:
paramsA LinphoneConferenceParams
enableIf true, video will be enabled during conference

Free a LinphoneConferenceParams

Parameters:
paramsLinphoneConferenceParams to free

Create a LinphoneConferenceParams with default parameters set.

Parameters:
coreLinphoneCore to use to find out the default parameters. Can be NULL.
Returns:
A freshly allocated LinphoneConferenceParams

Check whether video will be enable at conference starting

Returns:
if true, the video will be enable at conference starting

Remove a participant from a conference

Parameters:
objA LinphoneConference
uriSIP URI of the participant to remove
Warning:
The passed SIP URI must be one of the URIs returned by linphone_conference_get_participants()
Returns:
0 if succeeded, -1 if failed

Accept an incoming call.

Basically the application is notified of incoming calls within the call_state_changed callback of the LinphoneCoreVTable structure, where it will receive a LinphoneCallIncoming event with the associated LinphoneCall object. The application can later accept the call using this method.

Parameters:
lcthe LinphoneCore object
callthe LinphoneCall object representing the call to be answered.
int linphone_core_accept_call_update ( LinphoneCore lc,
LinphoneCall call,
const LinphoneCallParams params 
)

Accept call modifications initiated by other end.

This call may be performed in response to a LinphoneCallUpdatedByRemote state notification. When such notification arrives, the application can decide to call linphone_core_defer_update_call() so that it can have the time to prompt the user. linphone_call_get_remote_params() can be used to get information about the call parameters requested by the other party, such as whether a video stream is requested.

When the user accepts or refuse the change, linphone_core_accept_call_update() can be done to answer to the other party. If params is NULL, then the same call parameters established before the update request will continue to be used (no change). If params is not NULL, then the update will be accepted according to the parameters passed. Typical example is when a user accepts to start video, then params should indicate that video stream should be used (see linphone_call_params_enable_video()).

Parameters:
lcthe linphone core object.
callthe LinphoneCall object
paramsa LinphoneCallParams object describing the call parameters to accept.
Returns:
0 if successful, -1 otherwise (actually when this function call is performed outside ot LinphoneCallUpdatedByRemote state).

Accept an incoming call, with parameters.

Basically the application is notified of incoming calls within the call_state_changed callback of the LinphoneCoreVTable structure, where it will receive a LinphoneCallIncoming event with the associated LinphoneCall object. The application can later accept the call using this method.

Parameters:
lcthe LinphoneCore object
callthe LinphoneCall object representing the call to be answered.
paramsthe specific parameters for this call, for example whether video is accepted or not. Use NULL to use default parameters.

Accept an early media session for an incoming call. This is identical as calling linphone_core_accept_early_media_with_params() with NULL call parameters.

See also:
linphone_core_accept_early_media_with_params()
Parameters:
lcthe core
callthe incoming call
Returns:
0 if successful, -1 otherwise.

When receiving an incoming, accept to start a media session as early-media. This means the call is not accepted but audio & video streams can be established if the remote party supports early media. However, unlike after call acceptance, mic and camera input are not sent during early-media, though received audio & video are played normally. The call can then later be fully accepted using linphone_core_accept_call() or linphone_core_accept_call_with_params().

Parameters:
lcthe linphonecore
callthe call
paramsthe call params, can be NULL.
Returns:
0 if successful, -1 otherwise.

Add all current calls into the conference. If no conference is running a new internal conference context is created and all current calls are added to it.

Parameters:
lcLinphoneCore
Returns:
0 if succeeded. Negative number if failed

Add a participant to the conference. If no conference is going on a new internal conference context is created and the participant is added to it.

Parameters:
lcLinphoneCore
callThe current call with the participant to add
Returns:
0 if succeeded. Negative number if failed

Check if we do not have exceed the number of simultaneous call

Create a LinphoneCallParams suitable for linphone_core_invite_with_params(), linphone_core_accept_call_with_params(), linphone_core_accept_early_media_with_params(), linphone_core_accept_call_update(). The parameters are initialized according to the current LinphoneCore configuration and the current state of the LinphoneCall.

Parameters:
lcthe LinphoneCore
callthe call for which the parameters are to be build, or NULL in the case where the parameters are to be used for a new outgoing call.
Returns:
a new LinphoneCallParams

Create a conference

Parameters:
lcThe LinphoneCore instance where the conference will be created inside.
paramsParameters of the conference. See LinphoneConferenceParams.
Returns:
A pointer on the freshly created conference. That object will be automatically freed by the core after calling linphone_core_terminate_conference().

Decline a pending incoming call, with a reason.

Parameters:
lcthe linphone core
callthe LinphoneCall, must be in the IncomingReceived state.
reasonthe reason for rejecting the call: LinphoneReasonDeclined or LinphoneReasonBusy

When receiving a LinphoneCallUpdatedByRemote state notification, prevent LinphoneCore from performing an automatic answer.

When receiving a LinphoneCallUpdatedByRemote state notification (ie an incoming reINVITE), the default behaviour of LinphoneCore is defined by the "defer_update_default" option of the "sip" section of the config. If this option is 0 (the default) then the LinphoneCore automatically answers the reINIVTE with call parameters unchanged. However when for example when the remote party updated the call to propose a video stream, it can be useful to prompt the user before answering. This can be achieved by calling linphone_core_defer_call_update() during the call state notification, to deactivate the automatic answer that would just confirm the audio but reject the video. Then, when the user responds to dialog prompt, it becomes possible to call linphone_core_accept_call_update() to answer the reINVITE, with eventually video enabled in the LinphoneCallParams argument.

The LinphoneCallUpdatedByRemote notification can also arrive when receiving an INVITE without SDP. In such case, an unchanged offer is made in the 200Ok, and when the ACK containing the SDP answer is received, LinphoneCallUpdatedByRemote is triggered to notify the application of possible changes in the media session. However in such case defering the update has no meaning since we just generating an offer.

Returns:
0 if successful, -1 if the linphone_core_defer_call_update() was done outside a valid LinphoneCallUpdatedByRemote notification.

Join the local participant to the running conference

Parameters:
lcLinphoneCore
Returns:
0 if succeeded. Negative number if failed
LinphoneCall* linphone_core_find_call_from_uri ( const LinphoneCore lc,
const char *  uri 
)

Search from the list of current calls if a remote address match uri

Parameters:
lc
uriwhich should match call remote uri
Returns:
LinphoneCall or NULL is no match is found
LinphoneCall* linphone_core_get_call_by_remote_address ( LinphoneCore lc,
const char *  remote_address 
)

Get the call with the remote_address specified

Parameters:
lc
remote_address
Returns:
the LinphoneCall of the call if found

Get the call with the remote_address specified

Parameters:
lc
remote_address
Returns:
the LinphoneCall of the call if found
const bctbx_list_t* linphone_core_get_calls ( LinphoneCore lc)

Returns the current list of calls.

Parameters:
[in]lcThe LinphoneCore object
Returns:
A list of LinphoneCall objects.

Note that this list is read-only and might be changed by the core after a function call to linphone_core_iterate(). Similarly the LinphoneCall objects inside it might be destroyed without prior notice. To hold references to LinphoneCall object into your program, you must use linphone_call_ref().

Get the number of Call

Get a pointer on the internal conference object.

Parameters:
lcLinphoneCore
Returns:
A pointer on LinphoneConference or NULL if no conference are going on

Get the set input volume of the local participant

Parameters:
lcLinphoneCore
Returns:
A value inside [0.0 ; 1.0]

Get the number of participant in the running conference. The local participant is included in the count only if it is in the conference.

Parameters:
lcLinphoneCore
Returns:
The number of participant

Returns The _LinphoneCall struct of the current call if one is in call

Get the remote address of the current call.

Parameters:
[in]lcLinphoneCore object.
Returns:
The remote address of the current call or NULL if there is no current call.

Returns the delayed timeout

See linphone_core_set_delayed_timeout() for details.

Returns the in call timeout

See linphone_core_set_in_call_timeout() for details.

Returns the incoming call timeout

See linphone_core_set_inc_timeout() for details.

bool_t linphone_core_in_call ( const LinphoneCore lc)

Returns TRUE if there is a call running.

LinphoneCall* linphone_core_invite ( LinphoneCore lc,
const char *  url 
)

Initiates an outgoing call

Parameters:
lcthe LinphoneCore object
urlthe destination of the call (sip address, or phone number).

The application doesn't own a reference to the returned LinphoneCall object. Use linphone_call_ref() to safely keep the LinphoneCall pointer valid within your application.

Returns:
a LinphoneCall object or NULL in case of failure

Initiates an outgoing call given a destination LinphoneAddress

Parameters:
lcthe LinphoneCore object
addrthe destination of the call (sip address).

The LinphoneAddress can be constructed directly using linphone_address_new(), or created by linphone_core_interpret_url(). The application doesn't own a reference to the returned LinphoneCall object. Use linphone_call_ref() to safely keep the LinphoneCall pointer valid within your application.

Returns:
a LinphoneCall object or NULL in case of failure

Initiates an outgoing call given a destination LinphoneAddress

Parameters:
lcthe LinphoneCore object
addrthe destination of the call (sip address).
paramscall parameters

The LinphoneAddress can be constructed directly using linphone_address_new(), or created by linphone_core_interpret_url(). The application doesn't own a reference to the returned LinphoneCall object. Use linphone_call_ref() to safely keep the LinphoneCall pointer valid within your application.

Returns:
a LinphoneCall object or NULL in case of failure
LinphoneCall* linphone_core_invite_with_params ( LinphoneCore lc,
const char *  url,
const LinphoneCallParams p 
)

Initiates an outgoing call according to supplied call parameters

Parameters:
lcthe LinphoneCore object
urlthe destination of the call (sip address, or phone number).
pcall parameters

The application doesn't own a reference to the returned LinphoneCall object. Use linphone_call_ref() to safely keep the LinphoneCall pointer valid within your application.

Returns:
a LinphoneCall object or NULL in case of failure

Indicates whether the local participant is part of a conference.

Warning:
That function automatically fails in the case of conferences using a conferencet server (focus). If you use such a conference, you should use linphone_conference_remove_participant() instead.
Parameters:
lcthe linphone core
Returns:
TRUE if the local participant is in a conference, FALSE otherwise.

Tells whether there is an incoming invite pending.

Parameters:
[in]lcLinphoneCore object
Returns:
A boolean telling whether an incoming invite is pending or not.

Make the local participant leave the running conference

Parameters:
lcLinphoneCore
Returns:
0 if succeeded. Negative number if failed

Pause all currently running calls.

Pauses the call. If a music file has been setup using linphone_core_set_play_file(), this file will be played to the remote user.

int linphone_core_redirect_call ( LinphoneCore lc,
LinphoneCall call,
const char *  redirect_uri 
)

Redirect the specified call to the given redirect URI.

Parameters:
[in]lcLinphoneCore object.
[in]callThe LinphoneCall to redirect.
[in]redirect_uriThe URI to redirect the call to.
Returns:
0 if successful, -1 on error.

Remove a call from the conference.

Parameters:
lcthe linphone core
calla call that has been previously merged into the conference.

After removing the remote participant belonging to the supplied call, the call becomes a normal call in paused state. If one single remote participant is left alone together with the local user in the conference after the removal, then the conference is automatically transformed into a simple call in StreamsRunning state. The conference's resources are then automatically destroyed.

In other words, unless linphone_core_leave_conference() is explicitly called, the last remote participant of a conference is automatically put in a simple call in running state.

Returns:
0 if successful, -1 otherwise.

Resumes the call.

void linphone_core_set_delayed_timeout ( LinphoneCore lc,
int  seconds 
)

Set the in delayed timeout in seconds.

After this timeout period, a delayed call (internal call initialisation or resolution) is resumed.

void linphone_core_set_in_call_timeout ( LinphoneCore lc,
int  seconds 
)

Set the in call timeout in seconds.

After this timeout period, the call is automatically hangup.

void linphone_core_set_inc_timeout ( LinphoneCore lc,
int  seconds 
)

Set the incoming call timeout in seconds.

If an incoming call isn't answered for this timeout period, it is automatically declined.

Check if a call will need the sound resources in near future (typically an outgoing call that is awaiting response). In liblinphone, it is not possible to have two independant calls using sound device or camera at the same time. In order to prevent this situation, an application can use linphone_core_sound_resources_locked() to know whether it is possible at a given time to start a new outgoing call. When the function returns TRUE, an application should not allow the user to start an outgoing call.

Parameters:
lcThe LinphoneCore
int linphone_core_start_conference_recording ( LinphoneCore lc,
const char *  path 
)

Start recording the running conference

Parameters:
lcLinphoneCore
pathPath to the file where the recording will be written
Returns:
0 if succeeded. Negative number if failed

Stop recording the running conference

Parameters:
lcLinphoneCore
Returns:
0 if succeeded. Negative number if failed

Terminates all the calls.

Parameters:
lcThe LinphoneCore
int linphone_core_terminate_call ( LinphoneCore lc,
LinphoneCall the_call 
)

Terminates a call.

Parameters:
lcthe LinphoneCore
the_callthe LinphoneCall object representing the call to be terminated.

Terminate the running conference. If it is a local conference, all calls inside it will become back separate calls and will be put in LinphoneCallPaused state. If it is a conference involving a focus server, all calls inside the conference will be terminated.

Parameters:
lcLinphoneCore
Returns:
0 if succeeded. Negative number if failed
int linphone_core_transfer_call ( LinphoneCore lc,
LinphoneCall call,
const char *  url 
)

Performs a simple call transfer to the specified destination.

The remote endpoint is expected to issue a new call to the specified destination. The current call remains active and thus can be later paused or terminated.

It is possible to follow the progress of the transfer provided that transferee sends notification about it. In this case, the transfer_state_changed callback of the LinphoneCoreVTable is invoked to notify of the state of the new call at the other party. The notified states are LinphoneCallOutgoingInit , LinphoneCallOutgoingProgress, LinphoneCallOutgoingRinging and LinphoneCallConnected.

Transfer a call to destination of another running call. This is used for "attended transfer" scenarios.

Parameters:
lclinphone core object
calla running call you want to transfer
desta running call whose remote person will receive the transfer

The transfered call is supposed to be in paused state, so that it is able to accept the transfer immediately. The destination call is a call previously established to introduce the transfered person. This method will send a transfer request to the transfered person. The phone of the transfered is then expected to automatically call to the destination of the transfer. The receiver of the transfer will then automatically close the call with us (the 'dest' call).

It is possible to follow the progress of the transfer provided that transferee sends notification about it. In this case, the transfer_state_changed callback of the LinphoneCoreVTable is invoked to notify of the state of the new call at the other party. The notified states are LinphoneCallOutgoingInit , LinphoneCallOutgoingProgress, LinphoneCallOutgoingRinging and LinphoneCallConnected.

int linphone_core_update_call ( LinphoneCore lc,
LinphoneCall call,
const LinphoneCallParams params 
)

Updates a running call according to supplied call parameters or parameters changed in the LinphoneCore.

In this version this is limited to the following use cases:

In case no changes are requested through the LinphoneCallParams argument, then this argument can be omitted and set to NULL.

Parameters:
lcthe core
callthe call to be updated
paramsthe new call parameters to use. (may be NULL)
Returns:
0 if successful, -1 otherwise.
const char* linphone_privacy_to_string ( LinphonePrivacy  privacy)
Returns:
string value of LinphonePrivacy enum