diff --git a/include/linphone/api/c-address.h b/include/linphone/api/c-address.h index daf59a825..d4716c5b8 100644 --- a/include/linphone/api/c-address.h +++ b/include/linphone/api/c-address.h @@ -188,8 +188,8 @@ LINPHONE_PUBLIC bool_t linphone_address_weak_equal (const LinphoneAddress *addre LINPHONE_PUBLIC bool_t linphone_address_equal (const LinphoneAddress *address1, const LinphoneAddress *address2); /** -* Get the header encoded in the address. -* @param address the address + * Get the header encoded in the address. + * @param header_name the header name **/ LINPHONE_PUBLIC const char *linphone_address_get_header (const LinphoneAddress *address, const char *header_name); diff --git a/include/linphone/api/c-chat-message.h b/include/linphone/api/c-chat-message.h index 3bc7fe062..d37931c74 100644 --- a/include/linphone/api/c-chat-message.h +++ b/include/linphone/api/c-chat-message.h @@ -20,12 +20,12 @@ #ifndef _L_C_CHAT_MESSAGE_H_ #define _L_C_CHAT_MESSAGE_H_ -#include "linphone/api/c-types.h" #include "linphone/api/c-chat-message-cbs.h" +#include "linphone/api/c-types.h" #ifdef SQLITE_STORAGE_ENABLED -#include -#endif + #include +#endif // ifdef SQLITE_STORAGE_ENABLED // ============================================================================= @@ -37,7 +37,7 @@ typedef enum _LinphoneChatMessageDir{ // ============================================================================= #ifdef __cplusplus - extern "C" { + extern "C" { #endif // ifdef __cplusplus /** @@ -47,99 +47,101 @@ typedef enum _LinphoneChatMessageDir{ /** * Acquire a reference to the chat message. - * @param[in] cr The chat message. + * @param[in] msg #LinphoneChatMessage object. * @return The same chat message. -**/ -LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_message_ref(LinphoneChatMessage *msg); + */ +LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_message_ref (LinphoneChatMessage *msg); /** * Release reference to the chat message. - * @param[in] cr The chat message. -**/ -LINPHONE_PUBLIC void linphone_chat_message_unref(LinphoneChatMessage *msg); + * @param[in] msg #LinphoneChatMessage object. + */ +LINPHONE_PUBLIC void linphone_chat_message_unref (LinphoneChatMessage *msg); /** * Retrieve the user pointer associated with the chat message. - * @param[in] cr The chat message. + * @param[in] msg #LinphoneChatMessage object. * @return The user pointer associated with the chat message. -**/ -LINPHONE_PUBLIC void *linphone_chat_message_get_user_data(const LinphoneChatMessage *msg); + */ +LINPHONE_PUBLIC void *linphone_chat_message_get_user_data (const LinphoneChatMessage *msg); /** * Assign a user pointer to the chat message. - * @param[in] cr The chat message. + * @param[in] msg #LinphoneChatMessage object. * @param[in] ud The user pointer to associate with the chat message. -**/ -LINPHONE_PUBLIC void linphone_chat_message_set_user_data(LinphoneChatMessage *msg, void *ud); + */ +LINPHONE_PUBLIC void linphone_chat_message_set_user_data (LinphoneChatMessage *msg, void *ud); // ============================================================================= -LINPHONE_PUBLIC const char * linphone_chat_message_get_external_body_url(const LinphoneChatMessage *msg); +LINPHONE_PUBLIC const char *linphone_chat_message_get_external_body_url (const LinphoneChatMessage *msg); -LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url(LinphoneChatMessage *msg, const char *external_body_url); +LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url (LinphoneChatMessage *msg, const char *external_body_url); /** * Get the time the message was sent. + * @param[in] msg #LinphoneChatMessage object. */ -LINPHONE_PUBLIC time_t linphone_chat_message_get_time(const LinphoneChatMessage* msg); +LINPHONE_PUBLIC time_t linphone_chat_message_get_time (const LinphoneChatMessage *msg); /** * 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* msg); + * @param[in] msg #LinphoneChatMessage object. + */ +LINPHONE_PUBLIC bool_t linphone_chat_message_is_outgoing (LinphoneChatMessage *msg); /** * Get origin of the message - * @param[in] message #LinphoneChatMessage obj + * @param[in] msg #LinphoneChatMessage object. * @return #LinphoneAddress */ -LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_message_get_from_address(LinphoneChatMessage* msg); +LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_from_address (LinphoneChatMessage *msg); /** * Get destination of the message - * @param[in] message #LinphoneChatMessage obj + * @param[in] msg #LinphoneChatMessage object. * @return #LinphoneAddress */ -LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_message_get_to_address(LinphoneChatMessage* msg); +LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_to_address (LinphoneChatMessage *msg); /** * Get the content type of a chat message. - * @param[in] message #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return The content type of the chat message */ -LINPHONE_PUBLIC const char * linphone_chat_message_get_content_type(LinphoneChatMessage *msg); +LINPHONE_PUBLIC const char *linphone_chat_message_get_content_type (LinphoneChatMessage *msg); /** * Set the content type of a chat message. * This content type must match a content that is text representable, such as text/plain, text/html or image/svg+xml. - * @param[in] message #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @param[in] content_type The new content type of the chat message */ -LINPHONE_PUBLIC void linphone_chat_message_set_content_type(LinphoneChatMessage *msg, const char *content_type); +LINPHONE_PUBLIC void linphone_chat_message_set_content_type (LinphoneChatMessage *msg, const char *content_type); /** * Get text part of this message + * @param[in] msg #LinphoneChatMessage object. * @return text or NULL if no text. * @deprecated use getTextContent() instead */ -LINPHONE_PUBLIC const char* linphone_chat_message_get_text(LinphoneChatMessage* msg); +LINPHONE_PUBLIC const char *linphone_chat_message_get_text (LinphoneChatMessage* msg); /** * Get the message identifier. * It is used to identify a message so that it can be notified as delivered and/or displayed. - * @param[in] cm #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return The message identifier. */ -LINPHONE_PUBLIC const char* linphone_chat_message_get_message_id(const LinphoneChatMessage *msg); +LINPHONE_PUBLIC const char *linphone_chat_message_get_message_id (const 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 + * @param[in] msg #LinphoneChatMessage object. * @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_PUBLIC const char *linphone_chat_message_get_appdata (const LinphoneChatMessage *msg); /** * Linphone message has an app-specific field that can store a text. The application might want @@ -148,244 +150,253 @@ LINPHONE_PUBLIC const char* linphone_chat_message_get_appdata(const LinphoneChat * Invoking this function will attempt to update the message storage to reflect the changeif it is * enabled. * - * @param message #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @param data the data to store into the message */ -LINPHONE_PUBLIC void linphone_chat_message_set_appdata(LinphoneChatMessage* message, const char* data); +LINPHONE_PUBLIC void linphone_chat_message_set_appdata (LinphoneChatMessage *msg, const char *data); /** * Returns the chatroom this message belongs to. -**/ -LINPHONE_PUBLIC LinphoneChatRoom* linphone_chat_message_get_chat_room(const LinphoneChatMessage *msg); + * @param[in] msg #LinphoneChatMessage object. + */ +LINPHONE_PUBLIC LinphoneChatRoom *linphone_chat_message_get_chat_room (const LinphoneChatMessage *msg); /** * 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); +LINPHONE_PUBLIC const char *linphone_chat_message_get_file_transfer_filepath (LinphoneChatMessage *msg); // ============================================================================= /** * Get if a chat message is to be stored. - * @param[in] message #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return Whether or not the message is to be stored */ -LINPHONE_PUBLIC bool_t linphone_chat_message_get_to_be_stored(const LinphoneChatMessage *message); +LINPHONE_PUBLIC bool_t linphone_chat_message_get_to_be_stored (const LinphoneChatMessage *msg); /** * Set if a chat message is to be stored. * This content type must match a content that is text representable, such as text/plain, text/html or image/svg+xml. - * @param[in] message #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @param[in] to_be_stored Whether or not the chat message is to be stored */ -LINPHONE_PUBLIC void linphone_chat_message_set_to_be_stored(LinphoneChatMessage *message, bool_t to_be_stored); +LINPHONE_PUBLIC void linphone_chat_message_set_to_be_stored (LinphoneChatMessage *msg, bool_t to_be_stored); -LINPHONE_PUBLIC unsigned int linphone_chat_message_store(LinphoneChatMessage *msg); +LINPHONE_PUBLIC unsigned int linphone_chat_message_store (LinphoneChatMessage *msg); /** * Get the state of the message - *@param message #LinphoneChatMessage obj - *@return #LinphoneChatMessageState + * @param[in] msg #LinphoneChatMessage object. + * @return #LinphoneChatMessageState */ -LINPHONE_PUBLIC LinphoneChatMessageState linphone_chat_message_get_state(const LinphoneChatMessage* message); +LINPHONE_PUBLIC LinphoneChatMessageState linphone_chat_message_get_state (const LinphoneChatMessage *msg); /** * Get if the message was encrypted when transfered - * @param[in] message #LinphoneChatMessage obj + * @param[in] msg #LinphoneChatMessage object. * @return whether the message was encrypted when transfered or not */ -LINPHONE_PUBLIC bool_t linphone_chat_message_is_secured(LinphoneChatMessage *msg); +LINPHONE_PUBLIC bool_t linphone_chat_message_is_secured (LinphoneChatMessage *msg); /** * Linphone message can carry external body as defined by rfc2017 - * @param message #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @return external body url or NULL if not present. */ -LINPHONE_PUBLIC const char* linphone_chat_message_get_external_body_url(const LinphoneChatMessage* message); +LINPHONE_PUBLIC const char *linphone_chat_message_get_external_body_url (const LinphoneChatMessage *msg); /** * Linphone message can carry external body as defined by rfc2017 * - * @param message a #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @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); +LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url (LinphoneChatMessage *msg,const char *url); /** * Get the file_transfer_information (used by call backs to recover informations during a rcs file transfer) * - * @param message #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @return a pointer to the #LinphoneContent structure or NULL if not present. */ -LINPHONE_PUBLIC LinphoneContent* linphone_chat_message_get_file_transfer_information(LinphoneChatMessage* message); +LINPHONE_PUBLIC LinphoneContent *linphone_chat_message_get_file_transfer_information (LinphoneChatMessage *msg); /** * Return whether or not a chat message is a file tranfer. - * @param[in] message #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object * @return Whether or not the message is a file tranfer */ -LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer(LinphoneChatMessage *message); +LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer (LinphoneChatMessage *msg); /** * Return whether or not a chat message is a text. - * @param[in] message #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return Whether or not the message is a text */ -LINPHONE_PUBLIC bool_t linphone_chat_message_is_text(LinphoneChatMessage *message); +LINPHONE_PUBLIC bool_t linphone_chat_message_is_text (LinphoneChatMessage *msg); /** * Start the download of the file from remote server * - * @param message #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @param status_cb #LinphoneChatMessageStateChangeCb status callback invoked when file is downloaded or could not be downloaded * @param ud user data * @deprecated Use linphone_chat_message_download_file() instead. * @donotwrap */ -LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_start_file_download(LinphoneChatMessage* message, LinphoneChatMessageStateChangedCb status_cb, void* ud); +LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_start_file_download ( + LinphoneChatMessage *msg, + LinphoneChatMessageStateChangedCb status_cb, + void *ud +); /** * Start the download of the file referenced in a #LinphoneChatMessage from remote server. - * @param[in] message #LinphoneChatMessage object. + * @param[in] msg #LinphoneChatMessage object. */ -LINPHONE_PUBLIC LinphoneStatus linphone_chat_message_download_file(LinphoneChatMessage *message); +LINPHONE_PUBLIC LinphoneStatus linphone_chat_message_download_file (LinphoneChatMessage *msg); /** * Cancel an ongoing file transfer attached to this message.(upload or download) - * @param msg #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. */ -LINPHONE_PUBLIC void linphone_chat_message_cancel_file_transfer(LinphoneChatMessage* msg); +LINPHONE_PUBLIC void linphone_chat_message_cancel_file_transfer (LinphoneChatMessage *msg); /** * Send a chat message. - * @param[in] msg #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. */ LINPHONE_PUBLIC void linphone_chat_message_send (LinphoneChatMessage *msg); /** * Resend a chat message if it is in the 'not delivered' state for whatever reason. - * @param[in] msg #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @deprecated Use linphone_chat_message_send instead. * @donotwrap */ -LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_resend(LinphoneChatMessage *msg); +LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_resend (LinphoneChatMessage *msg); -LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_message_get_peer_address(LinphoneChatMessage *msg); +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 + * @param[in] msg #LinphoneChatMessage object. + * @return #LinphoneAddress */ -LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_local_address(LinphoneChatMessage* message); +LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_local_address (LinphoneChatMessage *msg); /** * Add custom headers to the message. - * @param message the message + * @param[in] msg #LinphoneChatMessage object. * @param header_name name of the header * @param header_value header value -**/ -LINPHONE_PUBLIC void linphone_chat_message_add_custom_header(LinphoneChatMessage* message, const char *header_name, const char *header_value); + */ +LINPHONE_PUBLIC void linphone_chat_message_add_custom_header ( + LinphoneChatMessage *msg, + const char *header_name, + const char *header_value +); /** * Retrieve a custom header value given its name. - * @param message the message + * @param[in] msg #LinphoneChatMessage object. * @param header_name header name searched -**/ -LINPHONE_PUBLIC const char * linphone_chat_message_get_custom_header(LinphoneChatMessage* message, const char *header_name); + */ +LINPHONE_PUBLIC const char * linphone_chat_message_get_custom_header (LinphoneChatMessage *msg, const char *header_name); /** * Removes a custom header from the message. - * @param msg the message + * @param[in] msg #LinphoneChatMessage object. * @param header_name name of the header to remove -**/ -LINPHONE_PUBLIC void linphone_chat_message_remove_custom_header(LinphoneChatMessage *msg, const char *header_name); + */ +LINPHONE_PUBLIC void linphone_chat_message_remove_custom_header (LinphoneChatMessage *msg, 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); + * @param[in] msg #LinphoneChatMessage object. + */ +LINPHONE_PUBLIC bool_t linphone_chat_message_is_read (LinphoneChatMessage *msg); -LINPHONE_PUBLIC LinphoneReason linphone_chat_message_get_reason(LinphoneChatMessage* msg); +LINPHONE_PUBLIC LinphoneReason linphone_chat_message_get_reason (LinphoneChatMessage *msg); /** * Get full details about delivery error of a chat message. - * @param msg a #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @return a #LinphoneErrorInfo describing the details. -**/ -LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_chat_message_get_error_info(const LinphoneChatMessage *msg); + */ +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] 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); +LINPHONE_PUBLIC void linphone_chat_message_set_file_transfer_filepath (LinphoneChatMessage *msg, const char *filepath); /** * Fulfill a chat message char by char. Message linked to a Real Time Text Call send char in realtime following RFC 4103/T.140 * To commit a message, use #linphone_chat_room_send_message - * @param[in] msg #LinphoneChatMessage + * @param[in] msg #LinphoneChatMessage object. * @param[in] character T.140 char * @returns 0 if succeed. */ -LINPHONE_PUBLIC LinphoneStatus linphone_chat_message_put_char(LinphoneChatMessage *msg,uint32_t character); +LINPHONE_PUBLIC LinphoneStatus linphone_chat_message_put_char (LinphoneChatMessage *msg, uint32_t character); /** * Get the #LinphoneChatMessageCbs object associated with the LinphoneChatMessage. - * @param[in] msg #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return The #LinphoneChatMessageCbs object associated with the LinphoneChatMessage. */ -LINPHONE_PUBLIC LinphoneChatMessageCbs * linphone_chat_message_get_callbacks(const LinphoneChatMessage *msg); +LINPHONE_PUBLIC LinphoneChatMessageCbs *linphone_chat_message_get_callbacks (const LinphoneChatMessage *msg); /** * Adds a content to the ChatMessage - * @param[in] msg #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @param[in] c_content #LinphoneContent object */ -LINPHONE_PUBLIC void linphone_chat_message_add_text_content(LinphoneChatMessage *msg, const char *c_content); +LINPHONE_PUBLIC void linphone_chat_message_add_text_content (LinphoneChatMessage *msg, const char *c_content); /** * Returns true if the chat message has a text content - * @param[in] msg #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return true if it has one, false otherwise */ -LINPHONE_PUBLIC bool_t linphone_chat_message_has_text_content(const LinphoneChatMessage *msg); +LINPHONE_PUBLIC bool_t linphone_chat_message_has_text_content (const LinphoneChatMessage *msg); /** * Gets the text content if available as a string - * @param[in] msg #LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return the #LinphoneContent buffer if available, null otherwise */ -LINPHONE_PUBLIC const char* linphone_chat_message_get_text_content(const LinphoneChatMessage *msg); +LINPHONE_PUBLIC const char *linphone_chat_message_get_text_content (const LinphoneChatMessage *msg); /** * Gets whether or not a file is currently being downloaded or uploaded - * @param[in] msg LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return true if download or upload is in progress, false otherwise */ -LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer_in_progress(LinphoneChatMessage *msg); +LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer_in_progress (LinphoneChatMessage *msg); /** * Gets the list of participants that displayed this message and the time at which they did. - * @param[in] msg LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return \bctbx_list{LinphoneParticipantImdnState} */ LINPHONE_PUBLIC bctbx_list_t *linphone_chat_message_get_participants_that_have_displayed (const LinphoneChatMessage *msg); /** * Gets the list of participants that did not receive this message. - * @param[in] msg LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return \bctbx_list{LinphoneParticipantImdnState} */ LINPHONE_PUBLIC bctbx_list_t *linphone_chat_message_get_participants_that_have_not_received (const LinphoneChatMessage *msg); /** * Gets the list of participants that received this message and the time at which they did. - * @param[in] msg LinphoneChatMessage object + * @param[in] msg #LinphoneChatMessage object. * @return \bctbx_list{LinphoneParticipantImdnState} */ LINPHONE_PUBLIC bctbx_list_t *linphone_chat_message_get_participants_that_have_received (const LinphoneChatMessage *msg); diff --git a/include/linphone/api/c-magic-search.h b/include/linphone/api/c-magic-search.h index e45bc2605..92b667346 100644 --- a/include/linphone/api/c-magic-search.h +++ b/include/linphone/api/c-magic-search.h @@ -22,9 +22,11 @@ #include "linphone/api/c-types.h" +// ============================================================================= + #ifdef __cplusplus -extern "C" { -#endif + extern "C" { +#endif // ifdef __cplusplus /** * @addtogroup misc @@ -34,88 +36,88 @@ extern "C" { /** * Constructs a LinphoneMagicSearch object **/ -LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_new(LinphoneCore *lc); +LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_new (LinphoneCore *lc); /** * Increment reference count of LinphoneMagicSearch object. **/ -LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_ref(LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_ref (LinphoneMagicSearch *magic_search); /** * Decrement reference count of LinphoneMagicSearch object. When dropped to zero, memory is freed. **/ -LINPHONE_PUBLIC void linphone_magic_search_unref(LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC void linphone_magic_search_unref (LinphoneMagicSearch *magic_search); /** * Set the minimum value used to calculate the weight in search * @param[in] weight minimum weight **/ -LINPHONE_PUBLIC void linphone_magic_search_set_min_weight(LinphoneMagicSearch *magicSearch, const unsigned int weight); +LINPHONE_PUBLIC void linphone_magic_search_set_min_weight (LinphoneMagicSearch *magic_search, unsigned int weight); /** * @return the minimum value used to calculate the weight in search **/ -LINPHONE_PUBLIC unsigned int linphone_magic_search_get_min_weight(const LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC unsigned int linphone_magic_search_get_min_weight (const LinphoneMagicSearch *magic_search); /** * Set the maximum value used to calculate the weight in search * @param[in] weight maximum weight **/ -LINPHONE_PUBLIC void linphone_magic_search_set_max_weight(LinphoneMagicSearch *magicSearch, const unsigned int weight); +LINPHONE_PUBLIC void linphone_magic_search_set_max_weight (LinphoneMagicSearch *magic_search, unsigned int weight); /** * @return the maximum value used to calculate the weight in search **/ -LINPHONE_PUBLIC unsigned int linphone_magic_search_get_max_weight(const LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC unsigned int linphone_magic_search_get_max_weight (const LinphoneMagicSearch *magic_search); /** * @return the delimiter used to find matched filter word **/ -LINPHONE_PUBLIC const char *linphone_magic_search_get_delimiter(const LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC const char *linphone_magic_search_get_delimiter (const LinphoneMagicSearch *magic_search); /** * Set the delimiter used to find matched filter word * @param[in] delimiter delimiter (example "-_.,") **/ -LINPHONE_PUBLIC void linphone_magic_search_set_delimiter(LinphoneMagicSearch *magicSearch, const char *delimiter); +LINPHONE_PUBLIC void linphone_magic_search_set_delimiter (LinphoneMagicSearch *magic_search, const char *delimiter); /** * @return if the delimiter search is used **/ -LINPHONE_PUBLIC bool_t linphone_magic_search_get_use_delimiter(LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC bool_t linphone_magic_search_get_use_delimiter (LinphoneMagicSearch *magic_search); /** * Enable or disable the delimiter in search * @param[in] enable **/ -LINPHONE_PUBLIC void linphone_magic_search_set_use_delimiter(LinphoneMagicSearch *magicSearch, bool_t enable); +LINPHONE_PUBLIC void linphone_magic_search_set_use_delimiter (LinphoneMagicSearch *magic_search, bool_t enable); /** * @return the number of the maximum SearchResult which will be return **/ -LINPHONE_PUBLIC unsigned int linphone_magic_search_get_search_limit(const LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC unsigned int linphone_magic_search_get_search_limit (const LinphoneMagicSearch *magic_search); /** * Set the number of the maximum SearchResult which will be return * @param[in] limit **/ -LINPHONE_PUBLIC void linphone_magic_search_set_search_limit(LinphoneMagicSearch *magicSearch, const unsigned int limit); +LINPHONE_PUBLIC void linphone_magic_search_set_search_limit (LinphoneMagicSearch *magic_search, unsigned int limit); /** * @return if the search is limited **/ -LINPHONE_PUBLIC bool_t linphone_magic_search_get_limited_search(const LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC bool_t linphone_magic_search_get_limited_search (const LinphoneMagicSearch *magic_search); /** * Enable or disable the limited search * @param[in] limited **/ -LINPHONE_PUBLIC void linphone_magic_search_set_limited_search(LinphoneMagicSearch *magicSearch, const bool_t limited); +LINPHONE_PUBLIC void linphone_magic_search_set_limited_search (LinphoneMagicSearch *magic_search, bool_t limited); /** * Reset the cache to begin a new search **/ -LINPHONE_PUBLIC void linphone_magic_search_reset_search_cache(LinphoneMagicSearch *magicSearch); +LINPHONE_PUBLIC void linphone_magic_search_reset_search_cache (LinphoneMagicSearch *magic_search); /** * Create a sorted list of SearchResult from SipUri, Contact name, @@ -124,13 +126,17 @@ LINPHONE_PUBLIC void linphone_magic_search_reset_search_cache(LinphoneMagicSearc * During the first search, a cache is created and used for the next search * Use linphone_magic_search_reset_search_cache() to begin a new search * @param[in] filter word we search - * @param[in] withDomain domain which we want to search only + * @param[in] domain domain which we want to search only * - "" for searching in all contact * - "*" for searching in contact with sip SipUri * - "yourdomain" for searching in contact from "yourdomain" domain * @return sorted list of \bctbx_list{LinphoneSearchResult} **/ -LINPHONE_PUBLIC bctbx_list_t* linphone_magic_search_get_contact_list_from_filter(LinphoneMagicSearch *magicSearch, const char *filter, const char *withDomain); +LINPHONE_PUBLIC bctbx_list_t* linphone_magic_search_get_contact_list_from_filter ( + LinphoneMagicSearch *magic_search, + const char *filter, + const char *domain +); /** * @} diff --git a/include/linphone/call_params.h b/include/linphone/call_params.h index 2da8b369e..37cf092dc 100644 --- a/include/linphone/call_params.h +++ b/include/linphone/call_params.h @@ -177,7 +177,7 @@ LINPHONE_PUBLIC float linphone_call_params_get_sent_framerate(const LinphoneCall LINPHONE_PUBLIC const LinphoneVideoDefinition * linphone_call_params_get_sent_video_definition(const LinphoneCallParams *cp); /** - * @biref Gets the size of the video that is sent. + * @brief Gets the size of the video that is sent. * @param[in] cp #LinphoneCalParams object * @return The sent video size or MS_VIDEO_SIZE_UNKNOWN if not available. * @deprecated Use #linphone_call_params_get_sent_video_definition() instead. Deprecated since 2017-03-28. diff --git a/include/linphone/callbacks.h b/include/linphone/callbacks.h index 319a9a4a9..adfdee602 100644 --- a/include/linphone/callbacks.h +++ b/include/linphone/callbacks.h @@ -522,7 +522,7 @@ typedef void (*LinphoneCoreCbsEcCalibrationResultCb)(LinphoneCore *lc, LinphoneE typedef void (*LinphoneCoreCbsEcCalibrationAudioInitCb)(LinphoneCore *lc); /** - * @biref Function prototype used by #linphone_core_cbs_set_ec_calibrator_audio_uninit(). + * @brief Function prototype used by #linphone_core_cbs_set_ec_calibrator_audio_uninit(). * @param lc The core. */ typedef void (*LinphoneCoreCbsEcCalibrationAudioUninitCb)(LinphoneCore *lc); diff --git a/include/linphone/core.h b/include/linphone/core.h index b68a2f362..b439cda8e 100644 --- a/include/linphone/core.h +++ b/include/linphone/core.h @@ -803,7 +803,7 @@ LINPHONE_PUBLIC char * linphone_core_compress_log_collection(void); LINPHONE_PUBLIC void linphone_core_reset_log_collection(void); /** - * @bref Define a log handler. + * @brief Define a log handler. * @param logfunc The function pointer of the log handler. * @deprecated Use #linphone_logging_service_cbs_set_log_message_written() instead. Deprecated since 2017-10-10. * @donotwrap @@ -1274,7 +1274,7 @@ LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneStatus linphone_core_decline_call(Li LINPHONE_PUBLIC LinphoneStatus linphone_core_terminate_all_calls(LinphoneCore *lc); /** - * @biref Pauses the call. If a music file has been setup using linphone_core_set_play_file(), + * @brief Pauses the call. If a music file has been setup using linphone_core_set_play_file(), * this file will be played to the remote user. * * The only way to resume a paused call is to call linphone_core_resume_call(). @@ -3507,7 +3507,7 @@ LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_core_set_preferred_video_size( LINPHONE_PUBLIC void linphone_core_set_preview_video_definition(LinphoneCore *lc, LinphoneVideoDefinition *vdef); /** - * @biref Sets the video size for the captured (preview) video. + * @brief 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. diff --git a/include/linphone/factory.h b/include/linphone/factory.h index 7722ea612..2389b9793 100644 --- a/include/linphone/factory.h +++ b/include/linphone/factory.h @@ -416,7 +416,7 @@ LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer_from_string(Linph /** * Creates an object #LinphoneConfig * @param[in] factory the #LinphoneFactory - * @param[in] the path of the config + * @param[in] path the path of the config * @return a #LinphoneConfig */ LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config(LinphoneFactory *factory, const char *path); @@ -424,8 +424,8 @@ LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config(LinphoneFactory * /** * Creates an object #LinphoneConfig * @param[in] factory the #LinphoneFactory - * @param[in] the path of the config - * @param[in] the path of the factory + * @param[in] path the path of the config + * @param[in] path the path of the factory * @return a #LinphoneConfig */ LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_with_factory(LinphoneFactory *factory, const char *path, const char *factory_path); @@ -433,6 +433,7 @@ LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_with_factory(Linp /** * Creates an object #LinphoneConfig * @param[in] factory the #LinphoneFactory + * @param[in] data the config data * @return a #LinphoneConfig */ LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_from_string(LinphoneFactory *factory, const char *data); @@ -454,14 +455,14 @@ LINPHONE_PUBLIC void linphone_factory_set_user_data(LinphoneFactory *factory, vo /** * Sets the log collection path * @param[in] factory the #LinphoneFactory - * @param[in] the path of the logs + * @param[in] path the path of the logs */ LINPHONE_PUBLIC void linphone_factory_set_log_collection_path(LinphoneFactory *factory, const char *path); /** * Enables or disables log collection * @param[in] factory the #LinphoneFactory - * @param[in] the policy for log collection + * @param[in] state the policy for log collection */ LINPHONE_PUBLIC void linphone_factory_enable_log_collection(LinphoneFactory *factory, LinphoneLogCollectionState state); diff --git a/src/c-wrapper/api/c-magic-search.cpp b/src/c-wrapper/api/c-magic-search.cpp index 028a64ba1..f5f9ebebd 100644 --- a/src/c-wrapper/api/c-magic-search.cpp +++ b/src/c-wrapper/api/c-magic-search.cpp @@ -17,15 +17,19 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#include "search/magic-search.h" #include "c-wrapper/c-wrapper.h" +#include "search/magic-search.h" + +// ============================================================================= using namespace std; L_DECLARE_C_OBJECT_IMPL(MagicSearch); LinphoneMagicSearch *linphone_core_create_magic_search(LinphoneCore *lc) { - shared_ptr cppPtr = make_shared(L_GET_CPP_PTR_FROM_C_OBJECT(lc)); + shared_ptr cppPtr = make_shared( + L_GET_CPP_PTR_FROM_C_OBJECT(lc) + ); LinphoneMagicSearch *object = L_INIT(MagicSearch); L_SET_CPP_PTR_FROM_C_OBJECT(object, cppPtr); @@ -36,67 +40,73 @@ LinphoneMagicSearch *linphone_magic_search_new(LinphoneCore *lc) { return linphone_core_create_magic_search(lc); } -LinphoneMagicSearch *linphone_magic_search_ref(LinphoneMagicSearch *magicSearch) { - belle_sip_object_ref(magicSearch); - return magicSearch; +LinphoneMagicSearch *linphone_magic_search_ref (LinphoneMagicSearch *magic_search) { + belle_sip_object_ref(magic_search); + return magic_search; } -void linphone_magic_search_unref(LinphoneMagicSearch *magicSearch) { - belle_sip_object_unref(magicSearch); +void linphone_magic_search_unref (LinphoneMagicSearch *magic_search) { + belle_sip_object_unref(magic_search); } -void linphone_magic_search_set_min_weight(LinphoneMagicSearch *magicSearch, const unsigned int weight) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->setMinWeight(weight); +void linphone_magic_search_set_min_weight (LinphoneMagicSearch *magic_search, unsigned int weight) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->setMinWeight(weight); } -unsigned int linphone_magic_search_get_min_weight(const LinphoneMagicSearch *magicSearch) { - return L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getMinWeight(); +unsigned int linphone_magic_search_get_min_weight (const LinphoneMagicSearch *magic_search) { + return L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getMinWeight(); } -void linphone_magic_search_set_max_weight(LinphoneMagicSearch *magicSearch, const unsigned int weight) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->setMaxWeight(weight); +void linphone_magic_search_set_max_weight (LinphoneMagicSearch *magic_search, unsigned int weight) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->setMaxWeight(weight); } -unsigned int linphone_magic_search_get_max_weight(const LinphoneMagicSearch *magicSearch) { - return L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getMaxWeight(); +unsigned int linphone_magic_search_get_max_weight (const LinphoneMagicSearch *magic_search) { + return L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getMaxWeight(); } -const char *linphone_magic_search_get_delimiter(const LinphoneMagicSearch *magicSearch) { - return L_STRING_TO_C(L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getDelimiter()); +const char *linphone_magic_search_get_delimiter (const LinphoneMagicSearch *magic_search) { + return L_STRING_TO_C(L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getDelimiter()); } -void linphone_magic_search_set_delimiter(LinphoneMagicSearch *magicSearch, const char *delimiter) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->setDelimiter(L_C_TO_STRING(delimiter)); +void linphone_magic_search_set_delimiter (LinphoneMagicSearch *magic_search, char *delimiter) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->setDelimiter(L_C_TO_STRING(delimiter)); } -bool_t linphone_magic_search_get_use_delimiter(LinphoneMagicSearch *magicSearch) { - return L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getUseDelimiter(); +bool_t linphone_magic_search_get_use_delimiter (LinphoneMagicSearch *magic_search) { + return L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getUseDelimiter(); } -void linphone_magic_search_set_use_delimiter(LinphoneMagicSearch *magicSearch, bool_t enable) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->setUseDelimiter(enable); +void linphone_magic_search_set_use_delimiter (LinphoneMagicSearch *magic_search, bool_t enable) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->setUseDelimiter(enable); } -unsigned int linphone_magic_search_get_search_limit(const LinphoneMagicSearch *magicSearch) { - return L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getSearchLimit(); +unsigned int linphone_magic_search_get_search_limit (const LinphoneMagicSearch *magic_search) { + return L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getSearchLimit(); } -void linphone_magic_search_set_search_limit(LinphoneMagicSearch *magicSearch, const unsigned int limit) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->setSearchLimit(limit); +void linphone_magic_search_set_search_limit (LinphoneMagicSearch *magic_search, unsigned int limit) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->setSearchLimit(limit); } -bool_t linphone_magic_search_get_limited_search(const LinphoneMagicSearch *magicSearch) { - return L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getLimitedSearch(); +bool_t linphone_magic_search_get_limited_search (const LinphoneMagicSearch *magic_search) { + return L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getLimitedSearch(); } -void linphone_magic_search_set_limited_search(LinphoneMagicSearch *magicSearch, const bool_t limited) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->setLimitedSearch(limited); +void linphone_magic_search_set_limited_search (LinphoneMagicSearch *magic_search, bool_t limited) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->setLimitedSearch(limited); } -void linphone_magic_search_reset_search_cache(LinphoneMagicSearch *magicSearch) { - L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->resetSearchCache(); +void linphone_magic_search_reset_search_cache (LinphoneMagicSearch *magic_search) { + L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->resetSearchCache(); } -bctbx_list_t* linphone_magic_search_get_contact_list_from_filter(LinphoneMagicSearch *magicSearch, const char *filter, const char *withDomain) { - return L_GET_RESOLVED_C_LIST_FROM_CPP_LIST(L_GET_CPP_PTR_FROM_C_OBJECT(magicSearch)->getContactListFromFilter(L_C_TO_STRING(filter), L_C_TO_STRING(withDomain))); +bctbx_list_t* linphone_magic_search_get_contact_list_from_filter ( + LinphoneMagicSearch *magic_search, + const char *filter, + const char *domain +) { + return L_GET_RESOLVED_C_LIST_FROM_CPP_LIST(L_GET_CPP_PTR_FROM_C_OBJECT(magic_search)->getContactListFromFilter( + L_C_TO_STRING(filter), L_C_TO_STRING(domain) + )); }