liblinphone  3.6.1
Typedefs | Enumerations | Functions
Placing and receiving calls

Typedefs

typedef struct _LinphoneCall LinphoneCall
 
typedef enum _LinphoneCallState LinphoneCallState
 

Enumerations

enum  _LinphoneCallState {
  LinphoneCallIdle,
  LinphoneCallIncomingReceived,
  LinphoneCallOutgoingInit,
  LinphoneCallOutgoingProgress,
  LinphoneCallOutgoingRinging,
  LinphoneCallOutgoingEarlyMedia,
  LinphoneCallConnected,
  LinphoneCallStreamsRunning,
  LinphoneCallPausing,
  LinphoneCallPaused,
  LinphoneCallResuming,
  LinphoneCallRefered,
  LinphoneCallError,
  LinphoneCallEnd,
  LinphoneCallPausedByRemote,
  LinphoneCallUpdatedByRemote,
  LinphoneCallIncomingEarlyMedia,
  LinphoneCallUpdating,
  LinphoneCallReleased
}
 

Functions

LinphoneCalllinphone_call_ref (LinphoneCall *obj)
 
void linphone_call_unref (LinphoneCall *obj)
 
const LinphoneCallParams * linphone_call_get_current_params (LinphoneCall *call)
 
const LinphoneCallParams * linphone_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)
 
void * linphone_call_get_user_pointer (LinphoneCall *call)
 
void linphone_call_set_user_pointer (LinphoneCall *call, void *user_pointer)
 
LinphoneCallLoglinphone_call_get_call_log (const LinphoneCall *call)
 
const char * linphone_call_get_refer_to (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)
 
int linphone_call_take_video_snapshot (LinphoneCall *call, const char *file)
 
bool_t linphone_call_camera_enabled (const LinphoneCall *call)
 
void linphone_call_params_enable_video (LinphoneCallParams *cp, bool_t enabled)
 
const PayloadType * linphone_call_params_get_used_audio_codec (const LinphoneCallParams *cp)
 
const PayloadType * linphone_call_params_get_used_video_codec (const LinphoneCallParams *cp)
 
bool_t linphone_call_params_low_bandwidth_enabled (const LinphoneCallParams *cp)
 
void linphone_call_params_enable_low_bandwidth (LinphoneCallParams *cp, bool_t enabled)
 
bool_t linphone_call_params_video_enabled (const LinphoneCallParams *cp)
 
enum LinphoneMediaEncryption linphone_call_params_get_media_encryption (const LinphoneCallParams *cp)
 
void linphone_call_params_set_media_encryption (LinphoneCallParams *cp, enum LinphoneMediaEncryption e)
 
void linphone_call_params_enable_early_media_sending (LinphoneCallParams *cp, bool_t enabled)
 
bool_t linphone_call_params_early_media_sending_enabled (const LinphoneCallParams *cp)
 
bool_t linphone_call_params_local_conference_mode (const LinphoneCallParams *cp)
 
void linphone_call_params_set_audio_bandwidth_limit (LinphoneCallParams *cp, int bandwidth)
 
LinphoneCallParams * linphone_call_params_copy (const LinphoneCallParams *cp)
 
void linphone_call_params_destroy (LinphoneCallParams *p)
 
LinphoneAddresslinphone_core_interpret_url (LinphoneCore *lc, const char *url)
 
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)
 
LinphoneCalllinphone_core_invite_address_with_params (LinphoneCore *lc, const LinphoneAddress *addr, const LinphoneCallParams *params)
 
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_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 MSList * 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 *the_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)
 
bool_t linphone_core_sound_resources_locked (LinphoneCore *lc)
 
bool_t linphone_call_is_in_conference (const LinphoneCall *call)
 
const LinphoneCalllinphone_core_find_call_from_uri (LinphoneCore *lc, const char *uri)
 

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.

Typedef Documentation

typedef struct _LinphoneCall LinphoneCall

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

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.

Enumeration Type Documentation

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

Function Documentation

LinphoneCall* linphone_call_ref ( LinphoneCall obj)

Increments the call 's reference count. 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().

void linphone_call_unref ( LinphoneCall obj)

Decrements the call object reference count. See linphone_call_ref().

const LinphoneCallParams* linphone_call_get_current_params ( LinphoneCall call)

Returns current parameters associated to the call.

const LinphoneCallParams* linphone_call_get_remote_params ( LinphoneCall call)

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.

const LinphoneAddress* linphone_call_get_remote_address ( const LinphoneCall call)

Returns the remote address associated to this call

char* linphone_call_get_remote_address_as_string ( const LinphoneCall call)

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

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

LinphoneCallState linphone_call_get_state ( const LinphoneCall call)

Retrieves the call's current state.

LinphoneReason linphone_call_get_reason ( const LinphoneCall call)

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

void* linphone_call_get_user_pointer ( LinphoneCall call)

Get the user_pointer in the LinphoneCall

return user_pointer an opaque user pointer that can be retrieved at any time

void linphone_call_set_user_pointer ( LinphoneCall call,
void *  user_pointer 
)

Set the user_pointer in the LinphoneCall

the user_pointer is an opaque user pointer that can be retrieved at any time in the LinphoneCall

LinphoneCallLog* linphone_call_get_call_log ( const LinphoneCall call)

Returns the call log associated to this call.

const char* linphone_call_get_refer_to ( const LinphoneCall call)

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

LinphoneCallDir linphone_call_get_dir ( const LinphoneCall call)

Returns direction of the call (incoming or outgoing).

const char* linphone_call_get_remote_user_agent ( LinphoneCall call)

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

const char* linphone_call_get_remote_contact ( LinphoneCall call)

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

bool_t linphone_call_has_transfer_pending ( const LinphoneCall 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.

int linphone_call_get_duration ( const LinphoneCall call)

Returns call's duration in seconds.

LinphoneCall* linphone_call_get_replaced_call ( LinphoneCall call)

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.

void linphone_call_enable_camera ( LinphoneCall call,
bool_t  enable 
)

Indicate whether camera input should be sent to remote end.

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.

bool_t linphone_call_camera_enabled ( const LinphoneCall call)

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

void linphone_call_params_enable_video ( LinphoneCallParams *  cp,
bool_t  enabled 
)

Enable video stream.

const PayloadType* linphone_call_params_get_used_audio_codec ( const LinphoneCallParams *  cp)

Returns the audio codec used in the call, described as a PayloadType structure.

const PayloadType* linphone_call_params_get_used_video_codec ( const LinphoneCallParams *  cp)

Returns the video codec used in the call, described as a PayloadType structure.

bool_t linphone_call_params_low_bandwidth_enabled ( const LinphoneCallParams *  cp)

Use to know if this call has been configured in low bandwidth mode. 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.

Returns
TRUE if low bandwidth has been configured/detected
void linphone_call_params_enable_low_bandwidth ( LinphoneCallParams *  cp,
bool_t  enabled 
)

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.

bool_t linphone_call_params_video_enabled ( const LinphoneCallParams *  cp)

Returns whether video is enabled.

enum LinphoneMediaEncryption linphone_call_params_get_media_encryption ( const LinphoneCallParams *  cp)

Returns kind of media encryption selected for the call.

void linphone_call_params_set_media_encryption ( LinphoneCallParams *  cp,
enum LinphoneMediaEncryption  e 
)

Set requested media encryption for a call.

void linphone_call_params_enable_early_media_sending ( LinphoneCallParams *  cp,
bool_t  enabled 
)

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

bool_t linphone_call_params_early_media_sending_enabled ( const LinphoneCallParams *  cp)

Indicates whether sending of early media was enabled.

bool_t linphone_call_params_local_conference_mode ( const LinphoneCallParams *  cp)

Returns true if the call is part of the locally managed conference.

void linphone_call_params_set_audio_bandwidth_limit ( LinphoneCallParams *  cp,
int  bandwidth 
)

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.

LinphoneCallParams* linphone_call_params_copy ( const LinphoneCallParams *  cp)

Copy existing LinphoneCallParams to a new LinphoneCallParams object.

void linphone_call_params_destroy ( LinphoneCallParams *  p)

Destroy LinphoneCallParams.

LinphoneAddress* linphone_core_interpret_url ( LinphoneCore lc,
const char *  url 
)

Interpret a call destination as supplied by the user, and returns a fully qualified LinphoneAddress.

A sip address should look like DisplayName <sip:username:port> . Basically this function performs the following tasks

  • if a phone number is entered, prepend country prefix of the default proxy configuration, eventually escape the '+' by 00.
  • if no domain part is supplied, append the domain name of the default proxy
  • if no sip: is present, prepend it

The result is a syntaxically correct SIP address.

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
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
LinphoneCall* linphone_core_invite_address ( LinphoneCore lc,
const LinphoneAddress addr 
)

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
LinphoneCall* linphone_core_invite_address_with_params ( LinphoneCore lc,
const LinphoneAddress addr,
const LinphoneCallParams *  params 
)

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
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.

int linphone_core_transfer_call_to_another ( LinphoneCore lc,
LinphoneCall call,
LinphoneCall dest 
)

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).

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.
int linphone_core_defer_call_update ( LinphoneCore lc,
LinphoneCall call 
)

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 to automatically answer 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 notifiacation, 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.

Returns
0 if successful, -1 if the linphone_core_defer_call_update() was done outside a LinphoneCallUpdatedByRemote notification, which is illegal.
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 sucessful, -1 otherwise (actually when this function call is performed outside ot LinphoneCallUpdatedByRemote state).
int linphone_core_accept_call ( LinphoneCore lc,
LinphoneCall call 
)

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_with_params ( LinphoneCore lc,
LinphoneCall call,
const LinphoneCallParams *  params 
)

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.
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.
int linphone_core_decline_call ( LinphoneCore lc,
LinphoneCall call,
LinphoneReason  reason 
)

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
int linphone_core_terminate_all_calls ( LinphoneCore lc)

Terminates all the calls.

Parameters
lcThe LinphoneCore
const MSList* linphone_core_get_calls ( LinphoneCore lc)

Returns the current list of calls.

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().

bool_t linphone_core_in_call ( const LinphoneCore lc)

Returns TRUE if there is a call running.

LinphoneCall* linphone_core_get_current_call ( const LinphoneCore lc)

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

int linphone_core_pause_call ( LinphoneCore lc,
LinphoneCall call 
)

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_pause_all_calls ( LinphoneCore lc)

Pause all currently running calls.

int linphone_core_resume_call ( LinphoneCore lc,
LinphoneCall the_call 
)

Resumes the call.

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
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.

int linphone_core_get_inc_timeout ( LinphoneCore lc)

Returns the incoming call timeout

See linphone_core_set_inc_timeout() for details.

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.

int linphone_core_get_in_call_timeout ( LinphoneCore lc)

Returns the in call timeout

See linphone_core_set_in_call_timeout() for details.

int linphone_core_get_delayed_timeout ( LinphoneCore lc)

Returns the delayed timeout

See linphone_core_set_delayed_timeout() for details.

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.

int linphone_core_get_calls_nb ( const LinphoneCore lc)

Get the number of Call

bool_t linphone_core_can_we_add_call ( LinphoneCore lc)

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

bool_t linphone_core_sound_resources_locked ( LinphoneCore lc)

Check if a call will need the sound resources.

Parameters
lcThe LinphoneCore
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.

Returns true if the call is part of the conference.

const LinphoneCall* linphone_core_find_call_from_uri ( 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