/* linphone Copyright (C) 2000 - 2010 Simon MORLAT (simon.morlat@linphone.org) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef LINPHONECORE_H #define LINPHONECORE_H #include "ortp/ortp.h" #include "ortp/payloadtype.h" #include "mediastreamer2/mscommon.h" #include "mediastreamer2/msvideo.h" #include "mediastreamer2/mediastream.h" #include "mediastreamer2/bitratecontrol.h" #ifdef IN_LINPHONE #include "sipsetup.h" #else #include "linphone/sipsetup.h" #endif #include "lpconfig.h" #define LINPHONE_IPADDR_SIZE 64 #define LINPHONE_HOSTNAME_SIZE 128 #ifndef LINPHONE_PUBLIC #define LINPHONE_PUBLIC MS2_PUBLIC #endif #ifdef __cplusplus extern "C" { #endif struct _LinphoneCore; /** * Linphone core main object created by function linphone_core_new() . * @ingroup initializing */ typedef struct _LinphoneCore LinphoneCore; /** * Disable a sip transport * Use with #LCSipTransports * @ingroup initializing */ #define LC_SIP_TRANSPORT_DISABLED 0 /** * Randomly chose a sip port for this transport * Use with #LCSipTransports * @ingroup initializing */ #define LC_SIP_TRANSPORT_RANDOM -1 /** * Linphone core SIP transport ports. * Use with #linphone_core_set_sip_transports * @ingroup initializing */ typedef struct _LCSipTransports{ /** * udp port to listening on, negative value if not set * */ int udp_port; /** * tcp port to listening on, negative value if not set * */ int tcp_port; /** * dtls port to listening on, negative value if not set * */ int dtls_port; /** * tls port to listening on, negative value if not set * */ int tls_port; } LCSipTransports; /** * Enum describing transport type for LinphoneAddress. * @ingroup linphone_address **/ enum _LinphoneTransportType{ LinphoneTransportUdp, LinphoneTransportTcp, LinphoneTransportTls, LinphoneTransportDtls }; /*this enum MUST be kept in sync with the SalTransport from sal.h*/ /** * Typedef for transport type enum. * @ingroup linphone_address **/ typedef enum _LinphoneTransportType LinphoneTransportType; /** * Object that represents a SIP address. * * The LinphoneAddress is an opaque object to represents SIP addresses, ie * the content of SIP's 'from' and 'to' headers. * A SIP address is made of display name, username, domain name, port, and various * uri headers (such as tags). It looks like 'Alice '. * The LinphoneAddress has methods to extract and manipulate all parts of the address. * When some part of the address (for example the username) is empty, the accessor methods * return NULL. * * @ingroup linphone_address */ typedef struct SalAddress LinphoneAddress; typedef struct belle_sip_dict LinphoneDictionary; /** * The LinphoneCall object represents a call issued or received by the LinphoneCore * @ingroup call_control **/ struct _LinphoneCall; /** * The LinphoneCall object represents a call issued or received by the LinphoneCore * @ingroup call_control **/ typedef struct _LinphoneCall LinphoneCall; /** * Enum describing various failure reasons or contextual information for some events. * @see linphone_call_get_reason() * @see linphone_proxy_config_get_error() * @see linphone_error_info_get_reason() * @ingroup misc **/ enum _LinphoneReason{ LinphoneReasonNone, LinphoneReasonNoResponse, /** */ LinphonePrivacyUser=0x1, /** * Request that privacy services modify headers that cannot * be set arbitrarily by the user (Contact/Via). */ LinphonePrivacyHeader=0x2, /** * Request that privacy services provide privacy for session * media */ LinphonePrivacySession=0x4, /** * 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 * */ LinphonePrivacyId=0x8, /** * Privacy service must perform the specified services or * fail the request * **/ LinphonePrivacyCritical=0x10, /** * Special keyword to use privacy as defined either globally or by proxy using linphone_proxy_config_set_privacy() */ LinphonePrivacyDefault=0x8000, } LinphonePrivacy; /* * a mask of #LinphonePrivacy values * */ typedef unsigned int LinphonePrivacyMask; LINPHONE_PUBLIC const char* linphone_privacy_to_string(LinphonePrivacy privacy); #ifdef IN_LINPHONE #include "buffer.h" #include "call_log.h" #include "call_params.h" #include "content.h" #include "event.h" #include "linphonefriend.h" #include "xmlrpc.h" #else #include "linphone/buffer.h" #include "linphone/call_log.h" #include "linphone/call_params.h" #include "linphone/content.h" #include "linphone/event.h" #include "linphone/linphonefriend.h" #include "linphone/xmlrpc.h" #endif LINPHONE_PUBLIC LinphoneAddress * linphone_address_new(const char *addr); LINPHONE_PUBLIC LinphoneAddress * linphone_address_clone(const LinphoneAddress *addr); LINPHONE_PUBLIC LinphoneAddress * linphone_address_ref(LinphoneAddress *addr); LINPHONE_PUBLIC void linphone_address_unref(LinphoneAddress *addr); LINPHONE_PUBLIC const char *linphone_address_get_scheme(const LinphoneAddress *u); LINPHONE_PUBLIC const char *linphone_address_get_display_name(const LinphoneAddress* u); LINPHONE_PUBLIC const char *linphone_address_get_username(const LinphoneAddress *u); LINPHONE_PUBLIC const char *linphone_address_get_domain(const LinphoneAddress *u); LINPHONE_PUBLIC int linphone_address_get_port(const LinphoneAddress *u); LINPHONE_PUBLIC void linphone_address_set_display_name(LinphoneAddress *u, const char *display_name); LINPHONE_PUBLIC void linphone_address_set_username(LinphoneAddress *uri, const char *username); LINPHONE_PUBLIC void linphone_address_set_domain(LinphoneAddress *uri, const char *host); LINPHONE_PUBLIC void linphone_address_set_port(LinphoneAddress *uri, int port); /*remove tags, params etc... so that it is displayable to the user*/ LINPHONE_PUBLIC void linphone_address_clean(LinphoneAddress *uri); LINPHONE_PUBLIC bool_t linphone_address_is_secure(const LinphoneAddress *addr); LINPHONE_PUBLIC bool_t linphone_address_get_secure(const LinphoneAddress *addr); LINPHONE_PUBLIC void linphone_address_set_secure(LinphoneAddress *addr, bool_t enabled); LINPHONE_PUBLIC bool_t linphone_address_is_sip(const LinphoneAddress *uri); LINPHONE_PUBLIC LinphoneTransportType linphone_address_get_transport(const LinphoneAddress *uri); LINPHONE_PUBLIC void linphone_address_set_transport(LinphoneAddress *uri,LinphoneTransportType type); LINPHONE_PUBLIC char *linphone_address_as_string(const LinphoneAddress *u); LINPHONE_PUBLIC char *linphone_address_as_string_uri_only(const LinphoneAddress *u); LINPHONE_PUBLIC bool_t linphone_address_weak_equal(const LinphoneAddress *a1, const LinphoneAddress *a2); LINPHONE_PUBLIC bool_t linphone_address_equal(const LinphoneAddress *a1, const LinphoneAddress *a2); LINPHONE_PUBLIC void linphone_address_set_password(LinphoneAddress *addr, const char *passwd); LINPHONE_PUBLIC const char *linphone_address_get_password(const LinphoneAddress *addr); LINPHONE_PUBLIC void linphone_address_set_header(LinphoneAddress *addr, const char *header_name, const char *header_value); LINPHONE_PUBLIC void linphone_address_destroy(LinphoneAddress *u); /** * Create a #LinphoneAddress object by parsing the user supplied address, given as a string. * @param[in] lc #LinphoneCore object * @param[in] address String containing the user supplied address * @return The create #LinphoneAddress object * @ingroup linphone_address */ LINPHONE_PUBLIC LinphoneAddress * linphone_core_create_address(LinphoneCore *lc, const char *address); struct _SipSetupContext; struct _LinphoneInfoMessage; /** * The LinphoneInfoMessage is an object representing an informational message sent or received by the core. **/ typedef struct _LinphoneInfoMessage LinphoneInfoMessage; LINPHONE_PUBLIC LinphoneInfoMessage *linphone_core_create_info_message(LinphoneCore*lc); LINPHONE_PUBLIC int linphone_call_send_info_message(struct _LinphoneCall *call, const LinphoneInfoMessage *info); LINPHONE_PUBLIC void linphone_info_message_add_header(LinphoneInfoMessage *im, const char *name, const char *value); LINPHONE_PUBLIC const char *linphone_info_message_get_header(const LinphoneInfoMessage *im, const char *name); LINPHONE_PUBLIC void linphone_info_message_set_content(LinphoneInfoMessage *im, const LinphoneContent *content); LINPHONE_PUBLIC const LinphoneContent * linphone_info_message_get_content(const LinphoneInfoMessage *im); LINPHONE_PUBLIC void linphone_info_message_destroy(LinphoneInfoMessage *im); LINPHONE_PUBLIC LinphoneInfoMessage *linphone_info_message_copy(const LinphoneInfoMessage *orig); /** * Structure describing policy regarding video streams establishments. * @ingroup media_parameters **/ struct _LinphoneVideoPolicy{ bool_t automatically_initiate; /** Can be created by linphone_chat_room_create_message(). */ typedef struct _LinphoneChatMessage LinphoneChatMessage; /** * A chat room is the place where text messages are exchanged. *
Can be created by linphone_core_create_chat_room(). */ typedef struct _LinphoneChatRoom LinphoneChatRoom; /** * LinphoneChatMessageState is used to notify if messages have been succesfully delivered or not. */ typedef enum _LinphoneChatMessageState { LinphoneChatMessageStateIdle, /**< Initial state */ LinphoneChatMessageStateInProgress, /**< Delivery in progress */ LinphoneChatMessageStateDelivered, /**< Message successfully delivered and acknowledged by remote end point */ LinphoneChatMessageStateNotDelivered, /**< Message was not delivered */ LinphoneChatMessageStateFileTransferError, /**< Message was received(and acknowledged) but cannot get file from server */ LinphoneChatMessageStateFileTransferDone /**< File transfer has been completed successfully. */ } LinphoneChatMessageState; /** * Call back used to notify message delivery status * @param msg #LinphoneChatMessage object * @param status LinphoneChatMessageState * @param ud application user data * @deprecated */ typedef void (*LinphoneChatMessageStateChangedCb)(LinphoneChatMessage* msg,LinphoneChatMessageState state,void* ud); /** * Call back used to notify message delivery status * @param msg #LinphoneChatMessage object * @param status LinphoneChatMessageState */ typedef void (*LinphoneChatMessageCbsMsgStateChangedCb)(LinphoneChatMessage* msg, LinphoneChatMessageState state); /** * File transfer receive callback prototype. This function is called by the core upon an incoming File transfer is started. This function may be call several time for the same file in case of large file. * @param message #LinphoneChatMessage message from which the body is received. * @param content #LinphoneContent incoming content information * @param buffer #LinphoneBuffer holding the received data. Empty buffer means end of file. */ typedef void (*LinphoneChatMessageCbsFileTransferRecvCb)(LinphoneChatMessage *message, const LinphoneContent* content, const LinphoneBuffer *buffer); /** * File transfer send callback prototype. This function is called by the core when an outgoing file transfer is started. This function is called until size is set to 0. * @param message #LinphoneChatMessage message from which the body is received. * @param content #LinphoneContent outgoing content * @param offset the offset in the file from where to get the data to be sent * @param size the number of bytes expected by the framework * @return A LinphoneBuffer object holding the data written by the application. An empty buffer means end of file. */ typedef LinphoneBuffer * (*LinphoneChatMessageCbsFileTransferSendCb)(LinphoneChatMessage *message, const LinphoneContent* content, size_t offset, size_t size); /** * File transfer progress indication callback prototype. * @param message #LinphoneChatMessage message from which the body is received. * @param content #LinphoneContent incoming content information * @param offset The number of bytes sent/received since the beginning of the transfer. * @param total The total number of bytes to be sent/received. */ typedef void (*LinphoneChatMessageCbsFileTransferProgressIndicationCb)(LinphoneChatMessage *message, const LinphoneContent* content, size_t offset, size_t total); LINPHONE_PUBLIC void linphone_core_set_chat_database_path(LinphoneCore *lc, const char *path); /** * Get a chat room whose peer is the supplied address. If it does not exist yet, it will be created. * No reference is transfered to the application. The LinphoneCore keeps a reference on the chat room. * @param lc the linphone core * @param addr a linphone address. * @return #LinphoneChatRoom where messaging can take place. **/ LINPHONE_PUBLIC LinphoneChatRoom *linphone_core_get_chat_room(LinphoneCore *lc, const LinphoneAddress *addr); /** * Get a chat room for messaging from a sip uri like sip:joe@sip.linphone.org. If it does not exist yet, it will be created. * No reference is transfered to the application. The LinphoneCore keeps a reference on the chat room. * @param lc The linphone core * @param to The destination address for messages. * @return #LinphoneChatRoom where messaging can take place. **/ LINPHONE_PUBLIC LinphoneChatRoom *linphone_core_get_chat_room_from_uri(LinphoneCore *lc, const char *to); /** * Removes a chatroom including all message history from the LinphoneCore. * @param lc The linphone core * @param to The chatroom. **/ LINPHONE_PUBLIC void linphone_core_delete_chat_room(LinphoneCore *lc, LinphoneChatRoom *cr); /** * Inconditionnaly disable incoming chat messages. * @param lc the core * @param deny_reason the deny reason (#LinphoneReasonNone has no effect). **/ LINPHONE_PUBLIC void linphone_core_disable_chat(LinphoneCore *lc, LinphoneReason deny_reason); /** * Enable reception of incoming chat messages. * By default it is enabled but it can be disabled with linphone_core_disable_chat(). * @param lc the core **/ LINPHONE_PUBLIC void linphone_core_enable_chat(LinphoneCore *lc); /** * Returns whether chat is enabled. **/ LINPHONE_PUBLIC bool_t linphone_core_chat_enabled(const LinphoneCore *lc); /** * Destroy a LinphoneChatRoom. * @param cr #LinphoneChatRoom object * @deprecated Use linphone_chat_room_unref() instead. */ LINPHONE_PUBLIC void linphone_chat_room_destroy(LinphoneChatRoom *cr); /** * Create a message attached to a dedicated chat room; * @param cr the chat room. * @param message text message, NULL if absent. * @return a new #LinphoneChatMessage */ LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_message(LinphoneChatRoom *cr,const char* message); /** * Create a message attached to a dedicated chat room; * @param cr the chat room. * @param message text message, NULL if absent. * @param external_body_url the URL given in external body or NULL. * @param state the LinphoneChatMessage.State of the message. * @param time the time_t at which the message has been received/sent. * @param is_read TRUE if the message should be flagged as read, FALSE otherwise. * @param is_incoming TRUE if the message has been received, FALSE otherwise. * @return a new #LinphoneChatMessage */ LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_message_2(LinphoneChatRoom *cr, const char* message, const char* external_body_url, LinphoneChatMessageState state, time_t time, bool_t is_read, bool_t is_incoming); /** * Acquire a reference to the chat room. * @param[in] cr The chat room. * @return The same chat room. **/ LINPHONE_PUBLIC LinphoneChatRoom *linphone_chat_room_ref(LinphoneChatRoom *cr); /** * Release reference to the chat room. * @param[in] cr The chat room. **/ LINPHONE_PUBLIC void linphone_chat_room_unref(LinphoneChatRoom *cr); /** * Retrieve the user pointer associated with the chat room. * @param[in] cr The chat room. * @return The user pointer associated with the chat room. **/ LINPHONE_PUBLIC void *linphone_chat_room_get_user_data(const LinphoneChatRoom *cr); /** * Assign a user pointer to the chat room. * @param[in] cr The chat room. * @param[in] ud The user pointer to associate with the chat room. **/ LINPHONE_PUBLIC void linphone_chat_room_set_user_data(LinphoneChatRoom *cr, void *ud); /** * Create a message attached to a dedicated chat room with a particular content. * Use #linphone_chat_room_send_message to initiate the transfer * @param cr the chat room. * @param initial_content #LinphoneContent initial content. #LinphoneCoreVTable.file_transfer_send is invoked later to notify file transfer progress and collect next chunk of the message if #LinphoneContent.data is NULL. * @return a new #LinphoneChatMessage */ LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_file_transfer_message(LinphoneChatRoom *cr, const LinphoneContent* initial_content); LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_room_get_peer_address(LinphoneChatRoom *cr); /** * Send a message to peer member of this chat room. * @deprecated Use linphone_chat_room_send_chat_message() instead. * @param cr #LinphoneChatRoom object * @param msg message to be sent */ LINPHONE_PUBLIC void linphone_chat_room_send_message(LinphoneChatRoom *cr, const char *msg); /** * Send a message to peer member of this chat room. * @param cr #LinphoneChatRoom object * @param msg #LinphoneChatMessage message to be sent * @param status_cb LinphoneChatMessageStateChangeCb status callback invoked when message is delivered or could not be delivered. May be NULL * @param ud user data for the status cb. * @deprecated Use linphone_chat_room_send_chat_message() instead. * @note The LinphoneChatMessage must not be destroyed until the the callback is called. * The LinphoneChatMessage reference is transfered to the function and thus doesn't need to be unref'd by the application. */ LINPHONE_PUBLIC void linphone_chat_room_send_message2(LinphoneChatRoom *cr, LinphoneChatMessage* msg,LinphoneChatMessageStateChangedCb status_cb,void* ud); /** * Send a message to peer member of this chat room. * @param[in] cr LinphoneChatRoom object * @param[in] msg LinphoneChatMessage object * The state of the message sending will be notified via the callbacks defined in the LinphoneChatMessageCbs object that can be obtained * by calling linphone_chat_message_get_callbacks(). * The LinphoneChatMessage reference is transfered to the function and thus doesn't need to be unref'd by the application. */ LINPHONE_PUBLIC void linphone_chat_room_send_chat_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg); /** * Mark all messages of the conversation as read * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. */ LINPHONE_PUBLIC void linphone_chat_room_mark_as_read(LinphoneChatRoom *cr); /** * Delete a message from the chat room history. * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. * @param[in] msg The #LinphoneChatMessage object to remove. */ LINPHONE_PUBLIC void linphone_chat_room_delete_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg); /** * Delete all messages from the history * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. */ LINPHONE_PUBLIC void linphone_chat_room_delete_history(LinphoneChatRoom *cr); /** * Gets the number of messages in a chat room. * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which size has to be computed * @return the number of messages. */ LINPHONE_PUBLIC int linphone_chat_room_get_history_size(LinphoneChatRoom *cr); /** * Gets nb_message most recent messages from cr chat room, sorted from oldest to most recent. * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which messages should be retrieved * @param[in] nb_message Number of message to retrieve. 0 means everything. * @return \mslist{LinphoneChatMessage} */ LINPHONE_PUBLIC MSList *linphone_chat_room_get_history(LinphoneChatRoom *cr,int nb_message); /** * Gets the partial list of messages in the given range, sorted from oldest to most recent. * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which messages should be retrieved * @param[in] begin The first message of the range to be retrieved. History most recent message has index 0. * @param[in] end The last message of the range to be retrieved. History oldest message has index of history size - 1 (use #linphone_chat_room_get_history_size to retrieve history size) * @return \mslist{LinphoneChatMessage} */ LINPHONE_PUBLIC MSList *linphone_chat_room_get_history_range(LinphoneChatRoom *cr, int begin, int end); /** * Notifies the destination of the chat message being composed that the user is typing a new message. * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which a new message is being typed. */ LINPHONE_PUBLIC void linphone_chat_room_compose(LinphoneChatRoom *cr); /** * Tells whether the remote is currently composing a message. * @param[in] cr The "LinphoneChatRoom object corresponding to the conversation. * @return TRUE if the remote is currently composing a message, FALSE otherwise. */ LINPHONE_PUBLIC bool_t linphone_chat_room_is_remote_composing(const LinphoneChatRoom *cr); /** * Gets the number of unread messages in the chatroom. * @param[in] cr The "LinphoneChatRoom object corresponding to the conversation. * @return the number of unread messages. */ LINPHONE_PUBLIC int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *cr); /** * Returns back pointer to LinphoneCore object. * @deprecated use linphone_chat_room_get_core() **/ LINPHONE_PUBLIC LinphoneCore* linphone_chat_room_get_lc(LinphoneChatRoom *cr); /** * Returns back pointer to LinphoneCore object. **/ LINPHONE_PUBLIC LinphoneCore* linphone_chat_room_get_core(LinphoneChatRoom *cr); /** * Returns an list of chat rooms * @param[in] lc #LinphoneCore object * @return \mslist{LinphoneChatRoom} **/ LINPHONE_PUBLIC const MSList* linphone_core_get_chat_rooms(LinphoneCore *lc); LINPHONE_PUBLIC unsigned int linphone_chat_message_store(LinphoneChatMessage *msg); /** * Returns a #LinphoneChatMessageState as a string. */ LINPHONE_PUBLIC const char* linphone_chat_message_state_to_string(const LinphoneChatMessageState state); /** * Get the state of the message *@param message #LinphoneChatMessage obj *@return #LinphoneChatMessageState */ LINPHONE_PUBLIC LinphoneChatMessageState linphone_chat_message_get_state(const LinphoneChatMessage* message); /** * Duplicate a LinphoneChatMessage **/ LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_message_clone(const LinphoneChatMessage* message); /** * Acquire a reference to the chat message. * @param msg the chat message * @return the same chat message **/ LINPHONE_PUBLIC LinphoneChatMessage * linphone_chat_message_ref(LinphoneChatMessage *msg); /** * Release reference to the chat message. * @param msg the chat message. **/ LINPHONE_PUBLIC void linphone_chat_message_unref(LinphoneChatMessage *msg); /** * Destroys a LinphoneChatMessage. **/ LINPHONE_PUBLIC void linphone_chat_message_destroy(LinphoneChatMessage* msg); /** @deprecated Use linphone_chat_message_set_from_address() instead. */ #define linphone_chat_message_set_from(msg, addr) linphone_chat_message_set_from_address(msg, addr) /** * Set origin of the message * @param[in] message #LinphoneChatMessage obj * @param[in] from #LinphoneAddress origin of this message (copied) */ LINPHONE_PUBLIC void linphone_chat_message_set_from_address(LinphoneChatMessage* message, const LinphoneAddress* addr); /** @deprecated Use linphone_chat_message_get_from_address() instead. */ #define linphone_chat_message_get_from(msg) linphone_chat_message_get_from_address(msg) /** * Get origin of the message * @param[in] message #LinphoneChatMessage obj * @return #LinphoneAddress */ LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_message_get_from_address(const LinphoneChatMessage* message); #define linphone_chat_message_set_to(msg, addr) linphone_chat_message_set_to_address(msg, addr) /** * Set destination of the message * @param[in] message #LinphoneChatMessage obj * @param[in] to #LinphoneAddress destination of this message (copied) */ LINPHONE_PUBLIC void linphone_chat_message_set_to_address(LinphoneChatMessage* message, const LinphoneAddress* addr); /** @deprecated Use linphone_chat_message_get_to_address() instead. */ #define linphone_chat_message_get_to(msg) linphone_chat_message_get_to_address(msg) /** * Get destination of the message * @param[in] message #LinphoneChatMessage obj * @return #LinphoneAddress */ LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_message_get_to_address(const LinphoneChatMessage* message); /** * Linphone message can carry external body as defined by rfc2017 * @param message #LinphoneChatMessage * @return external body url or NULL if not present. */ LINPHONE_PUBLIC const char* linphone_chat_message_get_external_body_url(const LinphoneChatMessage* message); /** * Linphone message can carry external body as defined by rfc2017 * * @param message a LinphoneChatMessage * @param url ex: access-type=URL; URL="http://www.foo.com/file" */ LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url(LinphoneChatMessage* message,const char* url); /** * Get the file_transfer_information (used by call backs to recover informations during a rcs file transfer) * * @param message #LinphoneChatMessage * @return a pointer to the LinphoneContent structure or NULL if not present. */ LINPHONE_PUBLIC const LinphoneContent* linphone_chat_message_get_file_transfer_information(const LinphoneChatMessage* message); /** * Start the download of the file from remote server * * @param message #LinphoneChatMessage * @param status_cb LinphoneChatMessageStateChangeCb status callback invoked when file is downloaded or could not be downloaded * @deprecated Use linphone_chat_message_download_file() instead. */ LINPHONE_PUBLIC void linphone_chat_message_start_file_download(LinphoneChatMessage* message, LinphoneChatMessageStateChangedCb status_cb, void* ud); /** * Start the download of the file referenced in a LinphoneChatMessage from remote server. * @param[in] message LinphoneChatMessage object. */ LINPHONE_PUBLIC void linphone_chat_message_download_file(LinphoneChatMessage *message); /** * Cancel an ongoing file transfer attached to this message.(upload or download) * @param msg #LinphoneChatMessage */ LINPHONE_PUBLIC void linphone_chat_message_cancel_file_transfer(LinphoneChatMessage* msg); /** * Linphone message has an app-specific field that can store a text. The application might want * to use it for keeping data over restarts, like thumbnail image path. * @param message #LinphoneChatMessage * @return the application-specific data or NULL if none has been stored. */ LINPHONE_PUBLIC const char* linphone_chat_message_get_appdata(const LinphoneChatMessage* message); /** * Linphone message has an app-specific field that can store a text. The application might want * to use it for keeping data over restarts, like thumbnail image path. * * Invoking this function will attempt to update the message storage to reflect the changeif it is * enabled. * * @param message #LinphoneChatMessage * @param data the data to store into the message */ LINPHONE_PUBLIC void linphone_chat_message_set_appdata(LinphoneChatMessage* message, const char* data); /** * Get text part of this message * @return text or NULL if no text. */ LINPHONE_PUBLIC const char* linphone_chat_message_get_text(const LinphoneChatMessage* message); /** * Get the time the message was sent. */ LINPHONE_PUBLIC time_t linphone_chat_message_get_time(const LinphoneChatMessage* message); /** * User pointer get function */ LINPHONE_PUBLIC void* linphone_chat_message_get_user_data(const LinphoneChatMessage* message); /** *User pointer set function */ LINPHONE_PUBLIC void linphone_chat_message_set_user_data(LinphoneChatMessage* message,void*); /** * Returns the chatroom this message belongs to. **/ LINPHONE_PUBLIC LinphoneChatRoom* linphone_chat_message_get_chat_room(LinphoneChatMessage *msg); /** * get peer address \link linphone_core_get_chat_room() associated to \endlink this #LinphoneChatRoom * @param cr #LinphoneChatRoom object * @return #LinphoneAddress peer address */ LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_message_get_peer_address(LinphoneChatMessage *msg); /** * Returns the origin address of a message if it was a outgoing message, or the destination address if it was an incoming message. *@param message #LinphoneChatMessage obj *@return #LinphoneAddress */ LINPHONE_PUBLIC LinphoneAddress *linphone_chat_message_get_local_address(const LinphoneChatMessage* message); /** * Add custom headers to the message. * @param message the message * @param header_name name of the header_name * @param header_value header value **/ LINPHONE_PUBLIC void linphone_chat_message_add_custom_header(LinphoneChatMessage* message, const char *header_name, const char *header_value); /** * Retrieve a custom header value given its name. * @param message the message * @param header_name header name searched **/ LINPHONE_PUBLIC const char * linphone_chat_message_get_custom_header(LinphoneChatMessage* message, const char *header_name); /** * Returns TRUE if the message has been read, otherwise returns FALSE. * @param message the message **/ LINPHONE_PUBLIC bool_t linphone_chat_message_is_read(LinphoneChatMessage* message); /** * Returns TRUE if the message has been sent, returns FALSE if the message has been received. * @param message the message **/ LINPHONE_PUBLIC bool_t linphone_chat_message_is_outgoing(LinphoneChatMessage* message); /** * Returns the id used to identify this message in the storage database * @param message the message * @return the id */ LINPHONE_PUBLIC unsigned int linphone_chat_message_get_storage_id(LinphoneChatMessage* message); LINPHONE_PUBLIC LinphoneReason linphone_chat_message_get_reason(LinphoneChatMessage* msg); /** * Get full details about delivery error of a chat message. * @param msg a LinphoneChatMessage * @return a LinphoneErrorInfo describing the details. **/ LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_chat_message_get_error_info(const LinphoneChatMessage *msg); /** * Set the path to the file to read from or write to during the file transfer. * @param[in] msg LinphoneChatMessage object * @param[in] filepath The path to the file to use for the file transfer. */ LINPHONE_PUBLIC void linphone_chat_message_set_file_transfer_filepath(LinphoneChatMessage *msg, const char *filepath); /** * Get the path to the file to read from or write to during the file transfer. * @param[in] msg LinphoneChatMessage object * @return The path to the file to use for the file transfer. */ LINPHONE_PUBLIC const char * linphone_chat_message_get_file_transfer_filepath(LinphoneChatMessage *msg); /** * Get the LinphoneChatMessageCbs object associated with the LinphoneChatMessage. * @param[in] msg LinphoneChatMessage object * @return The LinphoneChatMessageCbs object associated with the LinphoneChatMessage. */ LINPHONE_PUBLIC LinphoneChatMessageCbs * linphone_chat_message_get_callbacks(const LinphoneChatMessage *msg); /** * Acquire a reference to the LinphoneChatMessageCbs object. * @param[in] cbs LinphoneChatMessageCbs object. * @return The same LinphoneChatMessageCbs object. */ LINPHONE_PUBLIC LinphoneChatMessageCbs * linphone_chat_message_cbs_ref(LinphoneChatMessageCbs *cbs); /** * Release reference to the LinphoneChatMessageCbs object. * @param[in] cbs LinphoneChatMessageCbs object. */ LINPHONE_PUBLIC void linphone_chat_message_cbs_unref(LinphoneChatMessageCbs *cbs); /** * Retrieve the user pointer associated with the LinphoneChatMessageCbs object. * @param[in] cbs LinphoneChatMessageCbs object. * @return The user pointer associated with the LinphoneChatMessageCbs object. */ LINPHONE_PUBLIC void *linphone_chat_message_cbs_get_user_data(const LinphoneChatMessageCbs *cbs); /** * Assign a user pointer to the LinphoneChatMessageCbs object. * @param[in] cbs LinphoneChatMessageCbs object. * @param[in] ud The user pointer to associate with the LinphoneChatMessageCbs object. */ LINPHONE_PUBLIC void linphone_chat_message_cbs_set_user_data(LinphoneChatMessageCbs *cbs, void *ud); /** * Get the message state changed callback. * @param[in] cbs LinphoneChatMessageCbs object. * @return The current message state changed callback. */ LINPHONE_PUBLIC LinphoneChatMessageCbsMsgStateChangedCb linphone_chat_message_cbs_get_msg_state_changed(const LinphoneChatMessageCbs *cbs); /** * Set the message state changed callback. * @param[in] cbs LinphoneChatMessageCbs object. * @param[in] cb The message state changed callback to be used. */ LINPHONE_PUBLIC void linphone_chat_message_cbs_set_msg_state_changed(LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsMsgStateChangedCb cb); /** * Get the file transfer receive callback. * @param[in] cbs LinphoneChatMessageCbs object. * @return The current file transfer receive callback. */ LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferRecvCb linphone_chat_message_cbs_get_file_transfer_recv(const LinphoneChatMessageCbs *cbs); /** * Set the file transfer receive callback. * @param[in] cbs LinphoneChatMessageCbs object. * @param[in] cb The file transfer receive callback to be used. */ LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_recv(LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferRecvCb cb); /** * Get the file transfer send callback. * @param[in] cbs LinphoneChatMessageCbs object. * @return The current file transfer send callback. */ LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferSendCb linphone_chat_message_cbs_get_file_transfer_send(const LinphoneChatMessageCbs *cbs); /** * Set the file transfer send callback. * @param[in] cbs LinphoneChatMessageCbs object. * @param[in] cb The file transfer send callback to be used. */ LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_send(LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferSendCb cb); /** * Get the file transfer progress indication callback. * @param[in] cbs LinphoneChatMessageCbs object. * @return The current file transfer progress indication callback. */ LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferProgressIndicationCb linphone_chat_message_cbs_get_file_transfer_progress_indication(const LinphoneChatMessageCbs *cbs); /** * Set the file transfer progress indication callback. * @param[in] cbs LinphoneChatMessageCbs object. * @param[in] cb The file transfer progress indication callback to be used. */ LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_progress_indication(LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferProgressIndicationCb cb); /** * @} */ /** * @addtogroup initializing * @{ **/ /** * LinphoneGlobalState describes the global state of the LinphoneCore object. * It is notified via the LinphoneCoreVTable::global_state_changed **/ typedef enum _LinphoneGlobalState{ LinphoneGlobalOff, LinphoneGlobalStartup, LinphoneGlobalOn, LinphoneGlobalShutdown, LinphoneGlobalConfiguring }LinphoneGlobalState; LINPHONE_PUBLIC const char *linphone_global_state_to_string(LinphoneGlobalState gs); /** * LinphoneCoreLogCollectionUploadState is used to notify if log collection upload have been succesfully delivered or not. */ typedef enum _LinphoneCoreLogCollectionUploadState { LinphoneCoreLogCollectionUploadStateInProgress, /**< Delivery in progress */ LinphoneCoreLogCollectionUploadStateDelivered, /**< Log collection upload successfully delivered and acknowledged by remote end point */ LinphoneCoreLogCollectionUploadStateNotDelivered, /**< Log collection upload was not delivered */ } LinphoneCoreLogCollectionUploadState; LINPHONE_PUBLIC const char *linphone_core_log_collection_upload_state_to_string(const LinphoneCoreLogCollectionUploadState lcus); /** * Global state notification callback. * @param lc * @param gstate the global state * @param message informational message. */ typedef void (*LinphoneCoreGlobalStateChangedCb)(LinphoneCore *lc, LinphoneGlobalState gstate, const char *message); /** * Call state notification callback. * @param lc the LinphoneCore * @param call the call object whose state is changed. * @param cstate the new state of the call * @param message an informational message about the state. */ typedef void (*LinphoneCoreCallStateChangedCb)(LinphoneCore *lc, LinphoneCall *call, LinphoneCallState cstate, const char *message); /** * Call encryption changed callback. * @param lc the LinphoneCore * @param call the call on which encryption is changed. * @param on whether encryption is activated. * @param authentication_token an authentication_token, currently set for ZRTP kind of encryption only. */ typedef void (*LinphoneCoreCallEncryptionChangedCb)(LinphoneCore *lc, LinphoneCall *call, bool_t on, const char *authentication_token); /** @ingroup Proxies * Registration state notification callback prototype * */ typedef void (*LinphoneCoreRegistrationStateChangedCb)(LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message); /** Callback prototype * @deprecated */ typedef void (*ShowInterfaceCb)(LinphoneCore *lc); /** Callback prototype * @deprecated */ typedef void (*DisplayStatusCb)(LinphoneCore *lc, const char *message); /** Callback prototype * @deprecated */ typedef void (*DisplayMessageCb)(LinphoneCore *lc, const char *message); /** Callback prototype * @deprecated */ typedef void (*DisplayUrlCb)(LinphoneCore *lc, const char *message, const char *url); /** Callback prototype */ typedef void (*LinphoneCoreCbFunc)(LinphoneCore *lc,void * user_data); /** * Report status change for a friend previously \link linphone_core_add_friend() added \endlink to #LinphoneCore. * @param lc #LinphoneCore object . * @param lf Updated #LinphoneFriend . */ typedef void (*LinphoneCoreNotifyPresenceReceivedCb)(LinphoneCore *lc, LinphoneFriend * lf); /** * Reports that a new subscription request has been received and wait for a decision. * Status on this subscription request is notified by \link linphone_friend_set_inc_subscribe_policy() changing policy \endlink for this friend * @param lc #LinphoneCore object * @param lf #LinphoneFriend corresponding to the subscriber * @param url of the subscriber * Callback prototype */ typedef void (*LinphoneCoreNewSubscriptionRequestedCb)(LinphoneCore *lc, LinphoneFriend *lf, const char *url); /** * Callback for requesting authentication information to application or user. * @param lc the LinphoneCore * @param realm the realm (domain) on which authentication is required. * @param username the username that needs to be authenticated. * Application shall reply to this callback using linphone_core_add_auth_info(). */ typedef void (*LinphoneCoreAuthInfoRequestedCb)(LinphoneCore *lc, const char *realm, const char *username, const char *domain); /** * Callback to notify a new call-log entry has been added. * This is done typically when a call terminates. * @param lc the LinphoneCore * @param newcl the new call log entry added. */ typedef void (*LinphoneCoreCallLogUpdatedCb)(LinphoneCore *lc, LinphoneCallLog *newcl); /** * Callback prototype * @deprecated use #LinphoneCoreMessageReceivedCb instead. * * @param lc #LinphoneCore object * @param room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case \link #LinphoneAddress the from \endlink is not present in any chat room. * @param from #LinphoneAddress from * @param message incoming message */ typedef void (*LinphoneCoreTextMessageReceivedCb)(LinphoneCore *lc, LinphoneChatRoom *room, const LinphoneAddress *from, const char *message); /** * Chat message callback prototype * * @param lc #LinphoneCore object * @param room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case \link #LinphoneAddress the from \endlink is not present in any chat room. * @param LinphoneChatMessage incoming message */ typedef void (*LinphoneCoreMessageReceivedCb)(LinphoneCore *lc, LinphoneChatRoom *room, LinphoneChatMessage *message); /** * File transfer receive callback prototype. This function is called by the core upon an incoming File transfer is started. This function may be call several time for the same file in case of large file. * * * @param lc #LinphoneCore object * @param message #LinphoneChatMessage message from which the body is received. * @param content #LinphoneContent incoming content information * @param buff pointer to the received data * @param size number of bytes to be read from buff. 0 means end of file. * */ typedef void (*LinphoneCoreFileTransferRecvCb)(LinphoneCore *lc, LinphoneChatMessage *message, const LinphoneContent* content, const char* buff, size_t size); /** * File transfer send callback prototype. This function is called by the core upon an outgoing File transfer is started. This function is called until size is set to 0. *
a #LinphoneContent with a size equal zero * * @param lc #LinphoneCore object * @param message #LinphoneChatMessage message from which the body is received. * @param content #LinphoneContent outgoing content * @param buff pointer to the buffer where data chunk shall be written by the app * @param size as input value, it represents the number of bytes expected by the framework. As output value, it means the number of bytes wrote by the application in the buffer. 0 means end of file. * */ typedef void (*LinphoneCoreFileTransferSendCb)(LinphoneCore *lc, LinphoneChatMessage *message, const LinphoneContent* content, char* buff, size_t* size); /** * File transfer progress indication callback prototype. * * @param lc #LinphoneCore object * @param message #LinphoneChatMessage message from which the body is received. * @param content #LinphoneContent incoming content information * @param offset The number of bytes sent/received since the beginning of the transfer. * @param total The total number of bytes to be sent/received. */ typedef void (*LinphoneCoreFileTransferProgressIndicationCb)(LinphoneCore *lc, LinphoneChatMessage *message, const LinphoneContent* content, size_t offset, size_t total); /** * Is composing notification callback prototype. * * @param[in] lc #LinphoneCore object * @param[in] room #LinphoneChatRoom involved in the conversation. */ typedef void (*LinphoneCoreIsComposingReceivedCb)(LinphoneCore *lc, LinphoneChatRoom *room); /** * Callback for being notified of DTMFs received. * @param lc the linphone core * @param call the call that received the dtmf * @param dtmf the ascii code of the dtmf */ typedef void (*LinphoneCoreDtmfReceivedCb)(LinphoneCore* lc, LinphoneCall *call, int dtmf); /** Callback prototype */ typedef void (*LinphoneCoreReferReceivedCb)(LinphoneCore *lc, const char *refer_to); /** Callback prototype */ typedef void (*LinphoneCoreBuddyInfoUpdatedCb)(LinphoneCore *lc, LinphoneFriend *lf); /** * Callback for notifying progresses of transfers. * @param lc the LinphoneCore * @param transfered the call that was transfered * @param new_call_state the state of the call to transfer target at the far end. */ typedef void (*LinphoneCoreTransferStateChangedCb)(LinphoneCore *lc, LinphoneCall *transfered, LinphoneCallState new_call_state); /** * Callback for receiving quality statistics for calls. * @param lc the LinphoneCore * @param call the call * @param stats the call statistics. */ typedef void (*LinphoneCoreCallStatsUpdatedCb)(LinphoneCore *lc, LinphoneCall *call, const LinphoneCallStats *stats); /** * Callback prototype for receiving info messages. * @param lc the LinphoneCore * @param call the call whose info message belongs to. * @param msg the info message. */ typedef void (*LinphoneCoreInfoReceivedCb)(LinphoneCore *lc, LinphoneCall *call, const LinphoneInfoMessage *msg); /** * LinphoneGlobalState describes the global state of the LinphoneCore object. * It is notified via the LinphoneCoreVTable::global_state_changed **/ typedef enum _LinphoneConfiguringState { LinphoneConfiguringSuccessful, LinphoneConfiguringFailed, LinphoneConfiguringSkipped } LinphoneConfiguringState; /** * Converts a _LinphoneConfiguringState enum to a string. * @ingroup misc **/ LINPHONE_PUBLIC const char *linphone_configuring_state_to_string(LinphoneConfiguringState cs); /** * Callback prototype for configuring status changes notification * @param lc the LinphoneCore * @param message informational message. */ typedef void (*LinphoneCoreConfiguringStatusCb)(LinphoneCore *lc, LinphoneConfiguringState status, const char *message); /** * Callback prototype for reporting network change either automatically detected or notified by #linphone_core_set_network_reachable. * @param lc the LinphoneCore * @param reachable true if network is reachable. */ typedef void (*LinphoneCoreNetworkReachableCb)(LinphoneCore *lc, bool_t reachable); /** * Callback prototype for reporting log collection upload state change. * @param[in] lc LinphoneCore object * @param[in] state The state of the log collection upload * @param[in] info Additional information: error message in case of error state, URL of uploaded file in case of success. */ typedef void (*LinphoneCoreLogCollectionUploadStateChangedCb)(LinphoneCore *lc, LinphoneCoreLogCollectionUploadState state, const char *info); /** * Callback prototype for reporting log collection upload progress indication. * @param[in] lc LinphoneCore object * @param[in] progress Percentage of the file size of the log collection already uploaded. */ typedef void (*LinphoneCoreLogCollectionUploadProgressIndicationCb)(LinphoneCore *lc, size_t offset, size_t total); /** * This structure holds all callbacks that the application should implement. * None is mandatory. **/ typedef struct _LinphoneCoreVTable{ LinphoneCoreGlobalStateChangedCb global_state_changed; /** A text message has been received */ LinphoneCoreFileTransferRecvCb file_transfer_recv; /**< @deprecated Callback to store file received attached to a #LinphoneChatMessage */ LinphoneCoreFileTransferSendCb file_transfer_send; /**< @deprecated Callback to collect file chunk to be sent for a #LinphoneChatMessage */ LinphoneCoreFileTransferProgressIndicationCb file_transfer_progress_indication; /**< @deprecated Callback to indicate file transfer progress */ LinphoneCoreNetworkReachableCb network_reachable; /**< Callback to report IP network status (I.E up/down )*/ LinphoneCoreLogCollectionUploadStateChangedCb log_collection_upload_state_changed; /**< Callback to upload collected logs */ LinphoneCoreLogCollectionUploadProgressIndicationCb log_collection_upload_progress_indication; /**< Callback to indicate log collection upload progress */ void *user_data; /**data field of the MSList points a PayloadType * structure holding the codec information. * It is possible to make copy of the list with ms_list_copy() in order to modify it * (such as the order of codecs). * @ingroup media_parameters **/ LINPHONE_PUBLIC const MSList *linphone_core_get_audio_codecs(const LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_set_audio_codecs(LinphoneCore *lc, MSList *codecs); /** * Returns the list of available video codecs. * @param[in] lc The LinphoneCore object * @return \mslist{PayloadType} * * This list is unmodifiable. The ->data field of the MSList points a PayloadType * structure holding the codec information. * It is possible to make copy of the list with ms_list_copy() in order to modify it * (such as the order of codecs). * @ingroup media_parameters **/ LINPHONE_PUBLIC const MSList *linphone_core_get_video_codecs(const LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_set_video_codecs(LinphoneCore *lc, MSList *codecs); LINPHONE_PUBLIC void linphone_core_enable_generic_confort_noise(LinphoneCore *lc, bool_t enabled); LINPHONE_PUBLIC bool_t linphone_core_generic_confort_noise_enabled(const LinphoneCore *lc); /** * Tells whether the specified payload type is enabled. * @param[in] lc #LinphoneCore object. * @param[in] pt The #LinphonePayloadType we want to know is enabled or not. * @return TRUE if the payload type is enabled, FALSE if disabled. * @ingroup media_parameters */ LINPHONE_PUBLIC bool_t linphone_core_payload_type_enabled(LinphoneCore *lc, const LinphonePayloadType *pt); /** * Tells whether the specified payload type represents a variable bitrate codec. * @param[in] lc #LinphoneCore object. * @param[in] pt The #LinphonePayloadType we want to know * @return TRUE if the payload type represents a VBR codec, FALSE if disabled. * @ingroup media_parameters */ LINPHONE_PUBLIC bool_t linphone_core_payload_type_is_vbr(LinphoneCore *lc, const LinphonePayloadType *pt); /** * Set an explicit bitrate (IP bitrate, not codec bitrate) for a given codec, in kbit/s. * @param[in] lc the #LinphoneCore object * @param[in] pt the #LinphonePayloadType to modify. * @param[in] bitrate the IP bitrate in kbit/s. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_set_payload_type_bitrate(LinphoneCore *lc, LinphonePayloadType *pt, int bitrate); /** * Get the bitrate explicitely set with linphone_core_set_payload_type_bitrate(). * @param[in] lc the #LinphoneCore object * @param[in] pt the #LinphonePayloadType to modify. * @return bitrate the IP bitrate in kbit/s, or -1 if an error occured. * @ingroup media_parameters **/ LINPHONE_PUBLIC int linphone_core_get_payload_type_bitrate(LinphoneCore *lc, const LinphonePayloadType *pt); /** * Enable or disable the use of the specified payload type. * @param[in] lc #LinphoneCore object. * @param[in] pt The #LinphonePayloadType to enable or disable. It can be retrieved using #linphone_core_find_payload_type * @param[in] enable TRUE to enable the payload type, FALSE to disable it. * @return 0 if successful, any other value otherwise. * @ingroup media_parameters */ LINPHONE_PUBLIC int linphone_core_enable_payload_type(LinphoneCore *lc, LinphonePayloadType *pt, bool_t enable); /** * Wildcard value used by #linphone_core_find_payload_type to ignore rate in search algorithm * @ingroup media_parameters */ #define LINPHONE_FIND_PAYLOAD_IGNORE_RATE -1 /** * Wildcard value used by #linphone_core_find_payload_type to ignore channel in search algorithm * @ingroup media_parameters */ #define LINPHONE_FIND_PAYLOAD_IGNORE_CHANNELS -1 /** * Get payload type from mime type and clock rate * @ingroup media_parameters * This function searches in audio and video codecs for the given payload type name and clockrate. * @param lc #LinphoneCore object * @param type payload mime type (I.E SPEEX, PCMU, VP8) * @param rate can be #LINPHONE_FIND_PAYLOAD_IGNORE_RATE * @param channels number of channels, can be #LINPHONE_FIND_PAYLOAD_IGNORE_CHANNELS * @return Returns NULL if not found. */ LINPHONE_PUBLIC LinphonePayloadType* linphone_core_find_payload_type(LinphoneCore* lc, const char* type, int rate, int channels) ; /** * @ingroup media_parameters * Returns the payload type number assigned for this codec. **/ LINPHONE_PUBLIC int linphone_core_get_payload_type_number(LinphoneCore *lc, const PayloadType *pt); /** * @ingroup media_parameters * Force a number for a payload type. The LinphoneCore does payload type number assignment automatically. THis function is to be used mainly for tests, in order * to override the automatic assignment mechanism. **/ LINPHONE_PUBLIC void linphone_core_set_payload_type_number(LinphoneCore *lc, PayloadType *pt, int number); LINPHONE_PUBLIC const char *linphone_core_get_payload_type_description(LinphoneCore *lc, PayloadType *pt); LINPHONE_PUBLIC bool_t linphone_core_check_payload_type_usability(LinphoneCore *lc, const PayloadType *pt); /** * @addtogroup proxies * @{ */ /** * Create a proxy config with default values from Linphone core. * @param[in] lc #LinphoneCore object * @return #LinphoneProxyConfig with default values set */ LINPHONE_PUBLIC LinphoneProxyConfig * linphone_core_create_proxy_config(LinphoneCore *lc); /** * Add a proxy configuration. * This will start registration on the proxy, if registration is enabled. **/ LINPHONE_PUBLIC int linphone_core_add_proxy_config(LinphoneCore *lc, LinphoneProxyConfig *config); /** * Erase all proxies from config. **/ LINPHONE_PUBLIC void linphone_core_clear_proxy_config(LinphoneCore *lc); /** * Removes a proxy configuration. * * LinphoneCore will then automatically unregister and place the proxy configuration * on a deleted list. For that reason, a removed proxy does NOT need to be freed. **/ LINPHONE_PUBLIC void linphone_core_remove_proxy_config(LinphoneCore *lc, LinphoneProxyConfig *config); /** * Returns an unmodifiable list of entered proxy configurations. * @param[in] lc The LinphoneCore object * @return \mslist{LinphoneProxyConfig} **/ LINPHONE_PUBLIC const MSList *linphone_core_get_proxy_config_list(const LinphoneCore *lc); /** @deprecated Use linphone_core_set_default_proxy_config() instead. */ #define linphone_core_set_default_proxy(lc, config) linphone_core_set_default_proxy_config(lc, config) LINPHONE_PUBLIC void linphone_core_set_default_proxy_index(LinphoneCore *lc, int index); /** * @return the default proxy configuration, that is the one used to determine the current identity. * @deprecated Use linphone_core_get_default_proxy_config() instead. **/ LINPHONE_PUBLIC int linphone_core_get_default_proxy(LinphoneCore *lc, LinphoneProxyConfig **config); /** * @return the default proxy configuration, that is the one used to determine the current identity. * @param[in] lc LinphoneCore object * @return The default proxy configuration. **/ LINPHONE_PUBLIC LinphoneProxyConfig * linphone_core_get_default_proxy_config(LinphoneCore *lc); /** * Sets the default proxy. * * This default proxy must be part of the list of already entered LinphoneProxyConfig. * Toggling it as default will make LinphoneCore use the identity associated with * the proxy configuration in all incoming and outgoing calls. * @param[in] lc LinphoneCore object * @param[in] config The proxy configuration to use as the default one. **/ LINPHONE_PUBLIC void linphone_core_set_default_proxy_config(LinphoneCore *lc, LinphoneProxyConfig *config); /** * @} */ /** * Create an authentication information with default values from Linphone core. * @param[in] lc #LinphoneCore object * @param[in] username String containing the username part of the authentication credentials * @param[in] userid String containing the username to use to calculate the authentication digest (optional) * @param[in] passwd String containing the password of the authentication credentials (optional, either passwd or ha1 must be set) * @param[in] ha1 String containing a ha1 hash of the password (optional, either passwd or ha1 must be set) * @param[in] realm String used to discriminate different SIP authentication domains (optional) * @param[in] domain String containing the SIP domain for which this authentication information is valid, if it has to be restricted for a single SIP domain. * @return #LinphoneAuthInfo with default values set * @ingroup authentication */ LINPHONE_PUBLIC LinphoneAuthInfo * linphone_core_create_auth_info(LinphoneCore *lc, const char *username, const char *userid, const char *passwd, const char *ha1, const char *realm, const char *domain); LINPHONE_PUBLIC void linphone_core_add_auth_info(LinphoneCore *lc, const LinphoneAuthInfo *info); LINPHONE_PUBLIC void linphone_core_remove_auth_info(LinphoneCore *lc, const LinphoneAuthInfo *info); LINPHONE_PUBLIC const MSList *linphone_core_get_auth_info_list(const LinphoneCore *lc); LINPHONE_PUBLIC const LinphoneAuthInfo *linphone_core_find_auth_info(LinphoneCore *lc, const char *realm, const char *username, const char *sip_domain); LINPHONE_PUBLIC void linphone_core_abort_authentication(LinphoneCore *lc, LinphoneAuthInfo *info); LINPHONE_PUBLIC void linphone_core_clear_all_auth_info(LinphoneCore *lc); /** * Enable or disable the audio adaptive jitter compensation. * @param[in] lc #LinphoneCore object * @param[in] enable TRUE to enable the audio adaptive jitter compensation, FALSE to disable it. * @ingroup media_parameters */ LINPHONE_PUBLIC void linphone_core_enable_audio_adaptive_jittcomp(LinphoneCore *lc, bool_t enable); /** * Tells whether the audio adaptive jitter compensation is enabled. * @param[in] lc #LinphoneCore object * @return TRUE if the audio adaptive jitter compensation is enabled, FALSE otherwise. * @ingroup media_parameters */ LINPHONE_PUBLIC bool_t linphone_core_audio_adaptive_jittcomp_enabled(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_audio_jittcomp(LinphoneCore *lc); /** * Sets the nominal audio jitter buffer size in milliseconds. * The value takes effect immediately for all running and pending calls, if any. * A value of 0 disables the jitter buffer. * * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_set_audio_jittcomp(LinphoneCore *lc, int milliseconds); /** * Enable or disable the video adaptive jitter compensation. * @param[in] lc #LinphoneCore object * @param[in] enable TRUE to enable the video adaptive jitter compensation, FALSE to disable it. * @ingroup media_parameters */ LINPHONE_PUBLIC void linphone_core_enable_video_adaptive_jittcomp(LinphoneCore *lc, bool_t enable); /** * Tells whether the video adaptive jitter compensation is enabled. * @param[in] lc #LinphoneCore object * @return TRUE if the video adaptive jitter compensation is enabled, FALSE otherwise. * @ingroup media_parameters */ LINPHONE_PUBLIC bool_t linphone_core_video_adaptive_jittcomp_enabled(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_video_jittcomp(LinphoneCore *lc); /** * Sets the nominal video jitter buffer size in milliseconds. * The value takes effect immediately for all running and pending calls, if any. * A value of 0 disables the jitter buffer. * * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_set_video_jittcomp(LinphoneCore *lc, int milliseconds); LINPHONE_PUBLIC int linphone_core_get_audio_port(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_get_audio_port_range(const LinphoneCore *lc, int *min_port, int *max_port); LINPHONE_PUBLIC int linphone_core_get_video_port(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_get_video_port_range(const LinphoneCore *lc, int *min_port, int *max_port); LINPHONE_PUBLIC int linphone_core_get_nortp_timeout(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_audio_port(LinphoneCore *lc, int port); LINPHONE_PUBLIC void linphone_core_set_audio_port_range(LinphoneCore *lc, int min_port, int max_port); LINPHONE_PUBLIC void linphone_core_set_video_port(LinphoneCore *lc, int port); LINPHONE_PUBLIC void linphone_core_set_video_port_range(LinphoneCore *lc, int min_port, int max_port); LINPHONE_PUBLIC void linphone_core_set_nortp_timeout(LinphoneCore *lc, int port); LINPHONE_PUBLIC void linphone_core_set_use_info_for_dtmf(LinphoneCore *lc, bool_t use_info); LINPHONE_PUBLIC bool_t linphone_core_get_use_info_for_dtmf(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_use_rfc2833_for_dtmf(LinphoneCore *lc,bool_t use_rfc2833); LINPHONE_PUBLIC bool_t linphone_core_get_use_rfc2833_for_dtmf(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_sip_port(LinphoneCore *lc, int port); LINPHONE_PUBLIC int linphone_core_get_sip_port(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_set_sip_transports(LinphoneCore *lc, const LCSipTransports *transports); LINPHONE_PUBLIC int linphone_core_get_sip_transports(LinphoneCore *lc, LCSipTransports *transports); LINPHONE_PUBLIC void linphone_core_get_sip_transports_used(LinphoneCore *lc, LCSipTransports *tr); LINPHONE_PUBLIC bool_t linphone_core_sip_transport_supported(const LinphoneCore *lc, LinphoneTransportType tp); /** * * Give access to the UDP sip socket. Can be useful to configure this socket as persistent I.E kCFStreamNetworkServiceType set to kCFStreamNetworkServiceTypeVoIP) * @param lc #LinphoneCore * @return socket file descriptor */ ortp_socket_t linphone_core_get_sip_socket(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_inc_timeout(LinphoneCore *lc, int seconds); LINPHONE_PUBLIC int linphone_core_get_inc_timeout(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_in_call_timeout(LinphoneCore *lc, int seconds); LINPHONE_PUBLIC int linphone_core_get_in_call_timeout(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_delayed_timeout(LinphoneCore *lc, int seconds); LINPHONE_PUBLIC int linphone_core_get_delayed_timeout(LinphoneCore *lc); /** * Set the STUN server address to use when the firewall policy is set to STUN. * @param[in] lc #LinphoneCore object * @param[in] server The STUN server address to use. * @ingroup network_parameters */ LINPHONE_PUBLIC void linphone_core_set_stun_server(LinphoneCore *lc, const char *server); /** * Get the STUN server address being used. * @param[in] lc #LinphoneCore object * @return The STUN server address being used. * @ingroup network_parameters */ LINPHONE_PUBLIC const char * linphone_core_get_stun_server(const LinphoneCore *lc); /** * @ingroup network_parameters * Return the availability of uPnP. * * @return true if uPnP is available otherwise return false. */ LINPHONE_PUBLIC bool_t linphone_core_upnp_available(void); /** * @ingroup network_parameters * Return the internal state of uPnP. * * @param lc #LinphoneCore * @return an LinphoneUpnpState. */ LINPHONE_PUBLIC LinphoneUpnpState linphone_core_get_upnp_state(const LinphoneCore *lc); /** * @ingroup network_parameters * Return the external ip address of router. * In some cases the uPnP can have an external ip address but not a usable uPnP * (state different of Ok). * * @param lc #LinphoneCore * @return a null terminated string containing the external ip address. If the * the external ip address is not available return null. */ LINPHONE_PUBLIC const char * linphone_core_get_upnp_external_ipaddress(const LinphoneCore *lc); /** * Set the public IP address of NAT when using the firewall policy is set to use NAT. * @param[in] lc #LinphoneCore object. * @param[in] addr The public IP address of NAT to use. * @ingroup network_parameters */ LINPHONE_PUBLIC void linphone_core_set_nat_address(LinphoneCore *lc, const char *addr); /** * Get the public IP address of NAT being used. * @param[in] lc #LinphoneCore object. * @return The public IP address of NAT being used. * @ingroup network_parameters */ LINPHONE_PUBLIC const char *linphone_core_get_nat_address(const LinphoneCore *lc); /** * Set the policy to use to pass through firewalls. * @param[in] lc #LinphoneCore object. * @param[in] pol The #LinphoneFirewallPolicy to use. * @ingroup network_parameters */ LINPHONE_PUBLIC void linphone_core_set_firewall_policy(LinphoneCore *lc, LinphoneFirewallPolicy pol); /** * Get the policy that is used to pass through firewalls. * @param[in] lc #LinphoneCore object. * @return The #LinphoneFirewallPolicy that is being used. * @ingroup network_parameters */ LINPHONE_PUBLIC LinphoneFirewallPolicy linphone_core_get_firewall_policy(const LinphoneCore *lc); /* sound functions */ /* returns a null terminated static array of string describing the sound devices */ LINPHONE_PUBLIC const char** linphone_core_get_sound_devices(LinphoneCore *lc); /** * Update detection of sound devices. * * Use this function when the application is notified of USB plug events, so that * list of available hardwares for sound playback and capture is updated. * @param[in] lc #LinphoneCore object. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_reload_sound_devices(LinphoneCore *lc); LINPHONE_PUBLIC bool_t linphone_core_sound_device_can_capture(LinphoneCore *lc, const char *device); LINPHONE_PUBLIC bool_t linphone_core_sound_device_can_playback(LinphoneCore *lc, const char *device); LINPHONE_PUBLIC int linphone_core_get_ring_level(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_play_level(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_rec_level(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_ring_level(LinphoneCore *lc, int level); LINPHONE_PUBLIC void linphone_core_set_play_level(LinphoneCore *lc, int level); LINPHONE_PUBLIC void linphone_core_set_mic_gain_db(LinphoneCore *lc, float level); LINPHONE_PUBLIC float linphone_core_get_mic_gain_db(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_playback_gain_db(LinphoneCore *lc, float level); LINPHONE_PUBLIC float linphone_core_get_playback_gain_db(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_rec_level(LinphoneCore *lc, int level); LINPHONE_PUBLIC const char * linphone_core_get_ringer_device(LinphoneCore *lc); LINPHONE_PUBLIC const char * linphone_core_get_playback_device(LinphoneCore *lc); LINPHONE_PUBLIC const char * linphone_core_get_capture_device(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_set_ringer_device(LinphoneCore *lc, const char * devid); LINPHONE_PUBLIC int linphone_core_set_playback_device(LinphoneCore *lc, const char * devid); LINPHONE_PUBLIC int linphone_core_set_capture_device(LinphoneCore *lc, const char * devid); char linphone_core_get_sound_source(LinphoneCore *lc); void linphone_core_set_sound_source(LinphoneCore *lc, char source); LINPHONE_PUBLIC void linphone_core_stop_ringing(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_ring(LinphoneCore *lc, const char *path); LINPHONE_PUBLIC const char *linphone_core_get_ring(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_verify_server_certificates(LinphoneCore *lc, bool_t yesno); LINPHONE_PUBLIC void linphone_core_verify_server_cn(LinphoneCore *lc, bool_t yesno); LINPHONE_PUBLIC void linphone_core_set_root_ca(LinphoneCore *lc, const char *path); LINPHONE_PUBLIC const char *linphone_core_get_root_ca(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_ringback(LinphoneCore *lc, const char *path); LINPHONE_PUBLIC const char * linphone_core_get_ringback(const LinphoneCore *lc); /** * Specify a ring back tone to be played to far end during incoming calls. * @param[in] lc #LinphoneCore object * @param[in] ring The path to the ring back tone to be played. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_set_remote_ringback_tone(LinphoneCore *lc, const char *ring); /** * Get the ring back tone played to far end during incoming calls. * @param[in] lc #LinphoneCore object * @ingroup media_parameters **/ LINPHONE_PUBLIC const char *linphone_core_get_remote_ringback_tone(const LinphoneCore *lc); /** * Enable or disable the ring play during an incoming early media call. * @param[in] lc #LinphoneCore object * @param[in] enable A boolean value telling whether to enable ringing during an incoming early media call. * @ingroup media_parameters */ LINPHONE_PUBLIC void linphone_core_set_ring_during_incoming_early_media(LinphoneCore *lc, bool_t enable); /** * Tells whether the ring play is enabled during an incoming early media call. * @param[in] lc #LinphoneCore object * @ingroup media_paramaters */ LINPHONE_PUBLIC bool_t linphone_core_get_ring_during_incoming_early_media(const LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_preview_ring(LinphoneCore *lc, const char *ring,LinphoneCoreCbFunc func,void * userdata); LINPHONE_PUBLIC int linphone_core_play_local(LinphoneCore *lc, const char *audiofile); LINPHONE_PUBLIC void linphone_core_enable_echo_cancellation(LinphoneCore *lc, bool_t val); LINPHONE_PUBLIC bool_t linphone_core_echo_cancellation_enabled(LinphoneCore *lc); /** * Enables or disable echo limiter. * @param[in] lc #LinphoneCore object. * @param[in] val TRUE to enable echo limiter, FALSE to disable it. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_echo_limiter(LinphoneCore *lc, bool_t val); /** * Tells whether echo limiter is enabled. * @param[in] lc #LinphoneCore object. * @return TRUE if the echo limiter is enabled, FALSE otherwise. * @ingroup media_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_echo_limiter_enabled(const LinphoneCore *lc); void linphone_core_enable_agc(LinphoneCore *lc, bool_t val); bool_t linphone_core_agc_enabled(const LinphoneCore *lc); /** * @deprecated Use #linphone_core_enable_mic instead. **/ LINPHONE_PUBLIC void linphone_core_mute_mic(LinphoneCore *lc, bool_t muted); /** * Get mic state. * @deprecated Use #linphone_core_mic_enabled instead **/ LINPHONE_PUBLIC bool_t linphone_core_is_mic_muted(LinphoneCore *lc); /** * Enable or disable the microphone. * @param[in] lc #LinphoneCore object * @param[in] enable TRUE to enable the microphone, FALSE to disable it. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_mic(LinphoneCore *lc, bool_t enable); /** * Tells whether the microphone is enabled. * @param[in] lc #LinphoneCore object * @return TRUE if the microphone is enabled, FALSE if disabled. * @ingroup media_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_mic_enabled(LinphoneCore *lc); LINPHONE_PUBLIC bool_t linphone_core_is_rtp_muted(LinphoneCore *lc); LINPHONE_PUBLIC bool_t linphone_core_get_rtp_no_xmit_on_audio_mute(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_rtp_no_xmit_on_audio_mute(LinphoneCore *lc, bool_t val); /******************************************************************************* * Call log related functions * ******************************************************************************/ /** * @addtogroup call_logs * @{ **/ /** * Get the list of call logs (past calls). * @param[in] lc LinphoneCore object * @return \mslist{LinphoneCallLog} **/ LINPHONE_PUBLIC const MSList * linphone_core_get_call_logs(LinphoneCore *lc); /** * Erase the call log. * @param[in] lc LinphoneCore object **/ LINPHONE_PUBLIC void linphone_core_clear_call_logs(LinphoneCore *lc); /** * Get the number of missed calls. * Once checked, this counter can be reset with linphone_core_reset_missed_calls_count(). * @param[in] lc #LinphoneCore object. * @return The number of missed calls. **/ LINPHONE_PUBLIC int linphone_core_get_missed_calls_count(LinphoneCore *lc); /** * Reset the counter of missed calls. * @param[in] lc #LinphoneCore object. **/ LINPHONE_PUBLIC void linphone_core_reset_missed_calls_count(LinphoneCore *lc); /** * Remove a specific call log from call history list. * This function destroys the call log object. It must not be accessed anymore by the application after calling this function. * @param[in] lc #LinphoneCore object * @param[in] call_log #LinphoneCallLog object to remove. **/ LINPHONE_PUBLIC void linphone_core_remove_call_log(LinphoneCore *lc, LinphoneCallLog *call_log); /** * @} **/ /* video support */ LINPHONE_PUBLIC bool_t linphone_core_video_supported(LinphoneCore *lc); /** * Enables video globally. * * This function does not have any effect during calls. It just indicates LinphoneCore to * initiate future calls with video or not. The two boolean parameters indicate in which * direction video is enabled. Setting both to false disables video entirely. * * @param lc The LinphoneCore object * @param vcap_enabled indicates whether video capture is enabled * @param display_enabled indicates whether video display should be shown * @ingroup media_parameters * @deprecated Use #linphone_core_enable_video_capture and #linphone_core_enable_video_display instead. **/ LINPHONE_PUBLIC void linphone_core_enable_video(LinphoneCore *lc, bool_t vcap_enabled, bool_t display_enabled); /** * Returns TRUE if video is enabled, FALSE otherwise. * @ingroup media_parameters * @deprecated Use #linphone_core_video_capture_enabled and #linphone_core_video_display_enabled instead. **/ LINPHONE_PUBLIC bool_t linphone_core_video_enabled(LinphoneCore *lc); /** * Enable or disable video capture. * * This function does not have any effect during calls. It just indicates the #LinphoneCore to * initiate future calls with video capture or not. * @param[in] lc #LinphoneCore object. * @param[in] enable TRUE to enable video capture, FALSE to disable it. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_video_capture(LinphoneCore *lc, bool_t enable); /** * Enable or disable video display. * * This function does not have any effect during calls. It just indicates the #LinphoneCore to * initiate future calls with video display or not. * @param[in] lc #LinphoneCore object. * @param[in] enable TRUE to enable video display, FALSE to disable it. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_video_display(LinphoneCore *lc, bool_t enable); /** * Enable or disable video source reuse when switching from preview to actual video call. * * This source reuse is useful when you always display the preview, even before calls are initiated. * By keeping the video source for the transition to a real video call, you will smooth out the * source close/reopen cycle. * * This function does not have any effect durfing calls. It just indicates the #LinphoneCore to * initiate future calls with video source reuse or not. * Also, at the end of a video call, the source will be closed whatsoever for now. * @param[in] lc #LinphoneCore object * @param[in] enable TRUE to enable video source reuse. FALSE to disable it for subsequent calls. * @ingroup media_parameters * */ LINPHONE_PUBLIC void linphone_core_enable_video_source_reuse(LinphoneCore* lc, bool_t enable); /** * Tells whether video capture is enabled. * @param[in] lc #LinphoneCore object. * @return TRUE if video capture is enabled, FALSE if disabled. * @ingroup media_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_video_capture_enabled(LinphoneCore *lc); /** * Tells whether video display is enabled. * @param[in] lc #LinphoneCore object. * @return TRUE if video display is enabled, FALSE if disabled. * @ingroup media_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_video_display_enabled(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_video_policy(LinphoneCore *lc, const LinphoneVideoPolicy *policy); LINPHONE_PUBLIC const LinphoneVideoPolicy *linphone_core_get_video_policy(LinphoneCore *lc); typedef struct MSVideoSizeDef{ MSVideoSize vsize; const char *name; }MSVideoSizeDef; /** * Returns the zero terminated table of supported video resolutions. * * @ingroup media_parameters **/ LINPHONE_PUBLIC const MSVideoSizeDef *linphone_core_get_supported_video_sizes(LinphoneCore *lc); /** * Sets the preferred video size. * * @ingroup media_parameters * This applies only to the stream that is captured and sent to the remote party, * since we accept all standard video size on the receive path. **/LINPHONE_PUBLIC void linphone_core_set_preferred_video_size(LinphoneCore *lc, MSVideoSize vsize); /** * Sets the video size for the captured (preview) video. * This method is for advanced usage where a video capture must be set independently of the size of the stream actually sent through the call. * This allows for example to have the preview window with HD resolution even if due to bandwidth constraint the sent video size is small. * Using this feature increases the CPU consumption, since a rescaling will be done internally. * @ingroup media_parameters * @param lc the linphone core * @param vsize the video resolution choosed for capuring and previewing. It can be (0,0) to not request any specific preview size and let the core optimize the processing. **/ LINPHONE_PUBLIC void linphone_core_set_preview_video_size(LinphoneCore *lc, MSVideoSize vsize); /** * Sets the preview video size by its name. See linphone_core_set_preview_video_size() for more information about this feature. * * @ingroup media_parameters * Video resolution names are: qcif, svga, cif, vga, 4cif, svga ... **/ LINPHONE_PUBLIC void linphone_core_set_preview_video_size_by_name(LinphoneCore *lc, const char *name); /** * Returns video size for the captured video if it was previously set by linphone_core_set_preview_video_size(), otherwise returns a 0,0 size. * @see linphone_core_set_preview_video_size() * @ingroup media_parameters * @param lc the core * @return a MSVideoSize **/ LINPHONE_PUBLIC MSVideoSize linphone_core_get_preview_video_size(const LinphoneCore *lc); /** * Returns the effective video size for the captured video as provided by the camera. * When preview is disabled or not yet started, this function returns a zeroed video size. * @see linphone_core_set_preview_video_size() * @ingroup media_parameters * @param lc the core * @return a MSVideoSize **/ LINPHONE_PUBLIC MSVideoSize linphone_core_get_current_preview_video_size(const LinphoneCore *lc); /** * Returns the current preferred video size for sending. * * @ingroup media_parameters **/ LINPHONE_PUBLIC MSVideoSize linphone_core_get_preferred_video_size(const LinphoneCore *lc); /** * Get the name of the current preferred video size for sending. * @param[in] lc #LinphoneCore object. * @return A string containing the name of the current preferred video size (to be freed with ms_free()). */ LINPHONE_PUBLIC char * linphone_core_get_preferred_video_size_name(const LinphoneCore *lc); /** * Sets the preferred video size by its name. * * @ingroup media_parameters * This is identical to linphone_core_set_preferred_video_size() except * that it takes the name of the video resolution as input. * Video resolution names are: qcif, svga, cif, vga, 4cif, svga ... **/ LINPHONE_PUBLIC void linphone_core_set_preferred_video_size_by_name(LinphoneCore *lc, const char *name); /** * Set the preferred frame rate for video. * Based on the available bandwidth constraints and network conditions, the video encoder * remains free to lower the framerate. There is no warranty that the preferred frame rate be the actual framerate. * used during a call. Default value is 0, which means "use encoder's default fps value". * @ingroup media_parameters * @param lc the LinphoneCore * @param fps the target frame rate in number of frames per seconds. **/ LINPHONE_PUBLIC void linphone_core_set_preferred_framerate(LinphoneCore *lc, float fps); /** * Returns the preferred video framerate, previously set by linphone_core_set_preferred_framerate(). * @ingroup media_parameters * @param lc the linphone core * @return frame rate in number of frames per seconds. **/ LINPHONE_PUBLIC float linphone_core_get_preferred_framerate(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_enable_video_preview(LinphoneCore *lc, bool_t val); LINPHONE_PUBLIC bool_t linphone_core_video_preview_enabled(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_enable_self_view(LinphoneCore *lc, bool_t val); LINPHONE_PUBLIC bool_t linphone_core_self_view_enabled(const LinphoneCore *lc); /** * Update detection of camera devices. * * Use this function when the application is notified of USB plug events, so that * list of available hardwares for video capture is updated. * @param[in] lc #LinphoneCore object. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_reload_video_devices(LinphoneCore *lc); /* returns a null terminated static array of string describing the webcams */ LINPHONE_PUBLIC const char** linphone_core_get_video_devices(const LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_set_video_device(LinphoneCore *lc, const char *id); LINPHONE_PUBLIC const char *linphone_core_get_video_device(const LinphoneCore *lc); /* Set and get static picture to be used when "Static picture" is the video device */ /** * Set the path to the image file to stream when "Static picture" is set as the video device. * @param[in] lc #LinphoneCore object. * @param[in] path The path to the image file to use. * @ingroup media_parameters */ LINPHONE_PUBLIC int linphone_core_set_static_picture(LinphoneCore *lc, const char *path); /** * Get the path to the image file streamed when "Static picture" is set as the video device. * @param[in] lc #LinphoneCore object. * @return The path to the image file streamed when "Static picture" is set as the video device. * @ingroup media_parameters */ LINPHONE_PUBLIC const char *linphone_core_get_static_picture(LinphoneCore *lc); /** * Set the frame rate for static picture. * @param[in] lc #LinphoneCore object. * @param[in] fps The new frame rate to use for static picture. * @ingroup media_parameters */ LINPHONE_PUBLIC int linphone_core_set_static_picture_fps(LinphoneCore *lc, float fps); /** * Get the frame rate for static picture * @param[in] lc #LinphoneCore object. * @return The frame rate used for static picture. * @ingroup media_parameters */ LINPHONE_PUBLIC float linphone_core_get_static_picture_fps(LinphoneCore *lc); /*function to be used for eventually setting window decorations (icons, title...)*/ LINPHONE_PUBLIC void * linphone_core_get_native_video_window_id(const LinphoneCore *lc); /** * @ingroup media_parameters * For MacOS, Linux, Windows: core will create its own window * */ #define LINPHONE_VIDEO_DISPLAY_AUTO (void*)((unsigned long) 0) /** * @ingroup media_parameters * For MacOS, Linux, Windows: do nothing * */ #define LINPHONE_VIDEO_DISPLAY_NONE (void*)((unsigned long) -1) /** * @ingroup media_parameters * Set the native video window id where the video is to be displayed. * For MacOS, Linux, Windows: if not set or LINPHONE_VIDEO_DISPLAY_AUTO the core will create its own window, unless the special id LINPHONE_VIDEO_DISPLAY_NONE is given. **/ LINPHONE_PUBLIC void linphone_core_set_native_video_window_id(LinphoneCore *lc, void *id); LINPHONE_PUBLIC void * linphone_core_get_native_preview_window_id(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_native_preview_window_id(LinphoneCore *lc, void *id); /** * Tells the core to use a separate window for local camera preview video, instead of * inserting local view within the remote video window. * @param[in] lc #LinphoneCore object. * @param[in] yesno TRUE to use a separate window, FALSE to insert the preview in the remote video window. * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_use_preview_window(LinphoneCore *lc, bool_t yesno); LINPHONE_PUBLIC int linphone_core_get_device_rotation(LinphoneCore *lc ); LINPHONE_PUBLIC void linphone_core_set_device_rotation(LinphoneCore *lc, int rotation); /** * Get the camera sensor rotation. * * This is needed on some mobile platforms to get the number of degrees the camera sensor * is rotated relative to the screen. * * @param lc The linphone core related to the operation * @return The camera sensor rotation in degrees (0 to 360) or -1 if it could not be retrieved */ LINPHONE_PUBLIC int linphone_core_get_camera_sensor_rotation(LinphoneCore *lc); /* start or stop streaming video in case of embedded window */ void linphone_core_show_video(LinphoneCore *lc, bool_t show); /** @deprecated Use linphone_core_set_use_files() instead. */ #define linphone_core_use_files(lc, yesno) linphone_core_set_use_files(lc, yesno) /** * Ask the core to stream audio from and to files, instead of using the soundcard. * @ingroup media_parameters * @param[in] lc LinphoneCore object * @param[in] yesno A boolean value asking to stream audio from and to files or not. **/ LINPHONE_PUBLIC void linphone_core_set_use_files(LinphoneCore *lc, bool_t yesno); /** * Get the wav file that is played when putting somebody on hold, * or when files are used instead of soundcards (see linphone_core_set_use_files()). * * The file is a 16 bit linear wav file. * @ingroup media_parameters * @param[in] lc LinphoneCore object * @return The path to the file that is played when putting somebody on hold. */ LINPHONE_PUBLIC const char * linphone_core_get_play_file(const LinphoneCore *lc); /** * Sets a wav file to be played when putting somebody on hold, * or when files are used instead of soundcards (see linphone_core_set_use_files()). * * The file must be a 16 bit linear wav file. * @ingroup media_parameters * @param[in] lc LinphoneCore object * @param[in] file The path to the file to be played when putting somebody on hold. **/ LINPHONE_PUBLIC void linphone_core_set_play_file(LinphoneCore *lc, const char *file); /** * Get the wav file where incoming stream is recorded, * when files are used instead of soundcards (see linphone_core_set_use_files()). * * This feature is different from call recording (linphone_call_params_set_record_file()) * The file is a 16 bit linear wav file. * @ingroup media_parameters * @param[in] lc LinphoneCore object * @return The path to the file where incoming stream is recorded. **/ LINPHONE_PUBLIC const char * linphone_core_get_record_file(const LinphoneCore *lc); /** * Sets a wav file where incoming stream is to be recorded, * when files are used instead of soundcards (see linphone_core_set_use_files()). * * This feature is different from call recording (linphone_call_params_set_record_file()) * The file will be a 16 bit linear wav file. * @ingroup media_parameters * @param[in] lc LinphoneCore object * @param[in] file The path to the file where incoming stream is to be recorded. **/ LINPHONE_PUBLIC void linphone_core_set_record_file(LinphoneCore *lc, const char *file); LINPHONE_PUBLIC void linphone_core_play_dtmf(LinphoneCore *lc, char dtmf, int duration_ms); LINPHONE_PUBLIC void linphone_core_stop_dtmf(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_current_call_duration(const LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_mtu(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_mtu(LinphoneCore *lc, int mtu); /** * @ingroup network_parameters * This method is called by the application to notify the linphone core library when network is reachable. * Calling this method with true trigger linphone to initiate a registration process for all proxies. * Calling this method disables the automatic network detection mode. It means you must call this method after each network state changes. */ LINPHONE_PUBLIC void linphone_core_set_network_reachable(LinphoneCore* lc,bool_t value); /** * @ingroup network_parameters * return network state either as positioned by the application or by linphone itself. */ LINPHONE_PUBLIC bool_t linphone_core_is_network_reachable(LinphoneCore* lc); /** * @ingroup network_parameters * enable signaling keep alive. small udp packet sent periodically to keep udp NAT association */ LINPHONE_PUBLIC void linphone_core_enable_keep_alive(LinphoneCore* lc,bool_t enable); /** * @ingroup network_parameters * Is signaling keep alive */ LINPHONE_PUBLIC bool_t linphone_core_keep_alive_enabled(LinphoneCore* lc); LINPHONE_PUBLIC void *linphone_core_get_user_data(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_user_data(LinphoneCore *lc, void *userdata); /* returns LpConfig object to read/write to the config file: usefull if you wish to extend the config file with your own sections */ LINPHONE_PUBLIC LpConfig * linphone_core_get_config(LinphoneCore *lc); /** * Create a LpConfig object from a user config file. * @param[in] lc #LinphoneCore object * @param[in] filename The filename of the config file to read to fill the instantiated LpConfig * @ingroup misc */ LINPHONE_PUBLIC LpConfig * linphone_core_create_lp_config(LinphoneCore *lc, const char *filename); /*set a callback for some blocking operations, it takes you informed of the progress of the operation*/ LINPHONE_PUBLIC void linphone_core_set_waiting_callback(LinphoneCore *lc, LinphoneCoreWaitingCallback cb, void *user_context); /*returns the list of registered SipSetup (linphonecore plugins) */ LINPHONE_PUBLIC const MSList * linphone_core_get_sip_setups(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_destroy(LinphoneCore *lc); /*for advanced users:*/ typedef RtpTransport * (*LinphoneCoreRtpTransportFactoryFunc)(void *data, int port); struct _LinphoneRtpTransportFactories{ LinphoneCoreRtpTransportFactoryFunc audio_rtp_func; void *audio_rtp_func_data; LinphoneCoreRtpTransportFactoryFunc audio_rtcp_func; void *audio_rtcp_func_data; LinphoneCoreRtpTransportFactoryFunc video_rtp_func; void *video_rtp_func_data; LinphoneCoreRtpTransportFactoryFunc video_rtcp_func; void *video_rtcp_func_data; }; typedef struct _LinphoneRtpTransportFactories LinphoneRtpTransportFactories; void linphone_core_set_rtp_transport_factories(LinphoneCore* lc, LinphoneRtpTransportFactories *factories); int linphone_core_get_current_call_stats(LinphoneCore *lc, rtp_stats_t *local, rtp_stats_t *remote); LINPHONE_PUBLIC int linphone_core_get_calls_nb(const LinphoneCore *lc); LINPHONE_PUBLIC const MSList *linphone_core_get_calls(LinphoneCore *lc); LINPHONE_PUBLIC LinphoneGlobalState linphone_core_get_global_state(const LinphoneCore *lc); /** * force registration refresh to be initiated upon next iterate * @ingroup proxies */ LINPHONE_PUBLIC void linphone_core_refresh_registers(LinphoneCore* lc); /** * Set the path to the file storing the zrtp secrets cache. * @param[in] lc #LinphoneCore object * @param[in] file The path to the file to use to store the zrtp secrets cache. * @ingroup initializing */ LINPHONE_PUBLIC void linphone_core_set_zrtp_secrets_file(LinphoneCore *lc, const char* file); /** * Get the path to the file storing the zrtp secrets cache. * @param[in] lc #LinphoneCore object. * @return The path to the file storing the zrtp secrets cache. * @ingroup initializing */ LINPHONE_PUBLIC const char *linphone_core_get_zrtp_secrets_file(LinphoneCore *lc); /** * Set the path to the directory storing the user's x509 certificates (used by dtls) * @param[in] lc #LinphoneCore object * @param[in] path The path to the directory to use to store the user's certificates. * @ingroup initializing */ LINPHONE_PUBLIC void linphone_core_set_user_certificates_path(LinphoneCore *lc, const char* path); /** * Get the path to the directory storing the user's certificates. * @param[in] lc #LinphoneCore object. * @returns The path to the directory storing the user's certificates. * @ingroup initializing */ LINPHONE_PUBLIC const char *linphone_core_get_user_certificates_path(LinphoneCore *lc); /** * Search from the list of current calls if a remote address match uri * @ingroup call_control * @param lc * @param uri which should match call remote uri * @return LinphoneCall or NULL is no match is found */ LINPHONE_PUBLIC LinphoneCall* linphone_core_find_call_from_uri(const LinphoneCore *lc, const char *uri); LINPHONE_PUBLIC int linphone_core_add_to_conference(LinphoneCore *lc, LinphoneCall *call); LINPHONE_PUBLIC int linphone_core_add_all_to_conference(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_remove_from_conference(LinphoneCore *lc, LinphoneCall *call); /** * Indicates whether the local participant is part of a conference. * @param lc the linphone core * @return TRUE if the local participant is in a conference, FALSE otherwise. **/ LINPHONE_PUBLIC bool_t linphone_core_is_in_conference(const LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_enter_conference(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_leave_conference(LinphoneCore *lc); LINPHONE_PUBLIC float linphone_core_get_conference_local_input_volume(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_terminate_conference(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_get_conference_size(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_start_conference_recording(LinphoneCore *lc, const char *path); LINPHONE_PUBLIC int linphone_core_stop_conference_recording(LinphoneCore *lc); /** * Get the maximum number of simultaneous calls Linphone core can manage at a time. All new call above this limit are declined with a busy answer * @ingroup initializing * @param lc core * @return max number of simultaneous calls */ LINPHONE_PUBLIC int linphone_core_get_max_calls(LinphoneCore *lc); /** * Set the maximum number of simultaneous calls Linphone core can manage at a time. All new call above this limit are declined with a busy answer * @ingroup initializing * @param lc core * @param max number of simultaneous calls */ LINPHONE_PUBLIC void linphone_core_set_max_calls(LinphoneCore *lc, int max); LINPHONE_PUBLIC bool_t linphone_core_sound_resources_locked(LinphoneCore *lc); /** * @ingroup initializing * Check if a media encryption type is supported * @param lc core * @param menc LinphoneMediaEncryption * @return whether a media encryption scheme is supported by the LinphoneCore engine **/ LINPHONE_PUBLIC bool_t linphone_core_media_encryption_supported(const LinphoneCore *lc, LinphoneMediaEncryption menc); /** * Choose the media encryption policy to be used for RTP packets. * @param[in] lc #LinphoneCore object. * @param[in] menc The media encryption policy to be used. * @return 0 if successful, any other value otherwise. * @ingroup media_parameters */ LINPHONE_PUBLIC int linphone_core_set_media_encryption(LinphoneCore *lc, LinphoneMediaEncryption menc); /** * Get the media encryption policy being used for RTP packets. * @param[in] lc #LinphoneCore object. * @return The media encryption policy being used. * @ingroup media_parameters */ LINPHONE_PUBLIC LinphoneMediaEncryption linphone_core_get_media_encryption(LinphoneCore *lc); /** * Get behaviour when encryption parameters negociation fails on outgoing call. * @param[in] lc #LinphoneCore object. * @return TRUE means the call will fail; FALSE means an INVITE will be resent with encryption disabled. * @ingroup media_parameters */ LINPHONE_PUBLIC bool_t linphone_core_is_media_encryption_mandatory(LinphoneCore *lc); /** * Define behaviour when encryption parameters negociation fails on outgoing call. * @param[in] lc #LinphoneCore object. * @param[in] m If set to TRUE call will fail; if set to FALSE will resend an INVITE with encryption disabled. * @ingroup media_parameters */ LINPHONE_PUBLIC void linphone_core_set_media_encryption_mandatory(LinphoneCore *lc, bool_t m); /** * Init call params using LinphoneCore's current configuration */ LINPHONE_PUBLIC void linphone_core_init_default_params(LinphoneCore*lc, LinphoneCallParams *params); /** * True if tunnel support was compiled. * @ingroup tunnel */ LINPHONE_PUBLIC bool_t linphone_core_tunnel_available(void); /** * Linphone tunnel object. * @ingroup tunnel */ typedef struct _LinphoneTunnel LinphoneTunnel; /** * get tunnel instance if available * @ingroup tunnel * @param lc core object * @returns LinphoneTunnel or NULL if not available */ LINPHONE_PUBLIC LinphoneTunnel *linphone_core_get_tunnel(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_sip_dscp(LinphoneCore *lc, int dscp); LINPHONE_PUBLIC int linphone_core_get_sip_dscp(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_audio_dscp(LinphoneCore *lc, int dscp); LINPHONE_PUBLIC int linphone_core_get_audio_dscp(const LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_video_dscp(LinphoneCore *lc, int dscp); LINPHONE_PUBLIC int linphone_core_get_video_dscp(const LinphoneCore *lc); LINPHONE_PUBLIC const char *linphone_core_get_video_display_filter(LinphoneCore *lc); LINPHONE_PUBLIC void linphone_core_set_video_display_filter(LinphoneCore *lc, const char *filtername); /** Contact Providers */ typedef unsigned int ContactSearchID; typedef struct _LinphoneContactSearch LinphoneContactSearch; typedef struct _LinphoneContactProvider LinphoneContactProvider; typedef void (*ContactSearchCallback)( LinphoneContactSearch* id, MSList* friends, void* data ); /* * Remote provisioning */ /** * Set URI where to download xml configuration file at startup. * This can also be set from configuration file or factory config file, from [misc] section, item "config-uri". * Calling this function does not load the configuration. It will write the value into configuration so that configuration * from remote URI will take place at next LinphoneCore start. * @param lc the linphone core * @param uri the http or https uri to use in order to download the configuration. * @ingroup initializing **/ LINPHONE_PUBLIC void linphone_core_set_provisioning_uri(LinphoneCore *lc, const char*uri); /** * Get provisioning URI. * @param lc the linphone core * @return the provisioning URI. * @ingroup initializing **/ LINPHONE_PUBLIC const char* linphone_core_get_provisioning_uri(const LinphoneCore *lc); /** * Gets if the provisioning URI should be removed after it's been applied successfully * @param lc the linphone core * @return TRUE if the provisioning URI should be removed, FALSE otherwise */ LINPHONE_PUBLIC bool_t linphone_core_is_provisioning_transient(LinphoneCore *lc); LINPHONE_PUBLIC int linphone_core_migrate_to_multi_transport(LinphoneCore *lc); /** * Control when media offer is sent in SIP INVITE. * @param lc the linphone core * @param enable true if INVITE has to be sent whitout SDP. * @ingroup network_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_sdp_200_ack(LinphoneCore *lc, bool_t enable); /** * Media offer control param for SIP INVITE. * @return true if INVITE has to be sent whitout SDP. * @ingroup network_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_sdp_200_ack_enabled(const LinphoneCore *lc); /** * Enum listing frequent telephony tones. **/ enum _LinphoneToneID{ LinphoneToneUndefined, /** For incoming calls behavior is unchanged. * @param core #LinphoneCore * @param yesno if yes, subsequent calls will propose multicast ip set by #linphone_core_set_audio_multicast_addr * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_audio_multicast(LinphoneCore *core, bool_t yesno); /** * Use to get multicast state of audio stream. * @param core #LinphoneCore * @return true if subsequent calls will propose multicast ip set by #linphone_core_set_audio_multicast_addr * @ingroup media_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_audio_multicast_enabled(const LinphoneCore *core); /** * Use to enable multicast rtp for video stream. * If enabled, outgoing calls put a multicast address from #linphone_core_get_video_multicast_addr into video cline. In case of outgoing call video stream is sent to this multicast address. *
For incoming calls behavior is unchanged. * @param core #LinphoneCore * @param yesno if yes, subsequent outgoing calls will propose multicast ip set by #linphone_core_set_video_multicast_addr * @ingroup media_parameters **/ LINPHONE_PUBLIC void linphone_core_enable_video_multicast(LinphoneCore *core, bool_t yesno); /** * Use to get multicast state of video stream. * @param core #LinphoneCore * @return true if subsequent calls will propose multicast ip set by #linphone_core_set_video_multicast_addr * @ingroup media_parameters **/ LINPHONE_PUBLIC bool_t linphone_core_video_multicast_enabled(const LinphoneCore *core); /** * Set the network simulator parameters. * Liblinphone has the capabability of simulating the effects of a network (latency, lost packets, jitter, max bandwidth). * Please refer to the oRTP documentation for the meaning of the parameters of the OrtpNetworkSimulatorParams structure. * This function has effect for future calls, but not for currently running calls, though this behavior may be changed in future versions. * @warning Due to design of network simulation in oRTP, simulation is applied independently for audio and video stream. This means for example that a bandwidth * limit of 250kbit/s will have no effect on an audio stream running at 40kbit/s while a videostream targetting 400kbit/s will be highly affected. * @param lc the LinphoneCore * @param params the parameters used for the network simulation. * @return 0 if successful, -1 otherwise. **/ LINPHONE_PUBLIC int linphone_core_set_network_simulator_params(LinphoneCore *lc, const OrtpNetworkSimulatorParams *params); /** * Get the previously set network simulation parameters. * @see linphone_core_set_network_simulator_params * @return a OrtpNetworkSimulatorParams structure. **/ LINPHONE_PUBLIC const OrtpNetworkSimulatorParams *linphone_core_get_network_simulator_params(const LinphoneCore *lc); /** * Set the video preset to be used for video calls. * @param[in] lc LinphoneCore object * @param[in] preset The name of the video preset to be used (can be NULL to use the default video preset). */ LINPHONE_PUBLIC void linphone_core_set_video_preset(LinphoneCore *lc, const char *preset); /** * Get the video preset used for video calls. * @param[in] lc LinphoneCore object * @return The name of the video preset used for video calls (can be NULL if the default video preset is used). */ LINPHONE_PUBLIC const char * linphone_core_get_video_preset(const LinphoneCore *lc); #ifdef __cplusplus } #endif #endif