]> sjero.net Git - linphone/blobdiff - coreapi/linphonecore.h
Add linphone_core_get_camera_sensor_rotation().
[linphone] / coreapi / linphonecore.h
index 2c2168646c6d38f4073532fabd3f87eba10fff88..50686a2c973934662dd43c8c3c958fe72240f111 100644 (file)
@@ -47,14 +47,30 @@ typedef struct _LinphoneCore LinphoneCore;
 struct _LpConfig;
 
 
-struct _LCSipTransports{
+/**
+ * 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;
 
-typedef struct _LCSipTransports LCSipTransports;
 
 /**
  * Object that represents a SIP address.
@@ -161,6 +177,7 @@ LinphoneAddress *linphone_call_log_get_to(LinphoneCallLog *cl);
 LinphoneAddress *linphone_call_log_get_remote_address(LinphoneCallLog *cl);
 LinphoneCallDir linphone_call_log_get_dir(LinphoneCallLog *cl);
 LinphoneCallStatus linphone_call_log_get_status(LinphoneCallLog *cl);
+LinphoneCallStatus linphone_call_log_video_enabled(LinphoneCallLog *cl);
 time_t linphone_call_log_get_start_date(LinphoneCallLog *cl);
 int linphone_call_log_get_duration(LinphoneCallLog *cl);
 float linphone_call_log_get_quality(LinphoneCallLog *cl);
@@ -326,14 +343,16 @@ struct _LinphoneCallStats {
        LinphoneUpnpState       upnp_state; /**< State of uPnP processing. */
        float download_bandwidth; /**<Download bandwidth measurement of received stream, expressed in kbit/s, including IP/UDP/RTP headers*/
        float upload_bandwidth; /**<Download bandwidth measurement of sent stream, expressed in kbit/s, including IP/UDP/RTP headers*/
+       float local_late_rate; /**<percentage of packet received too late over last second*/
+       float local_loss_rate; /**<percentage of lost packet over last second*/
 };
 
 /**
  * @}
 **/
 
-const LinphoneCallStats *linphone_call_get_audio_stats(const LinphoneCall *call);
-const LinphoneCallStats *linphone_call_get_video_stats(const LinphoneCall *call);
+const LinphoneCallStats *linphone_call_get_audio_stats(LinphoneCall *call);
+const LinphoneCallStats *linphone_call_get_video_stats(LinphoneCall *call);
 
 
 /** Callback prototype */
@@ -616,10 +635,14 @@ LinphoneAuthInfo *linphone_auth_info_new(const char *username, const char *useri
 void linphone_auth_info_set_passwd(LinphoneAuthInfo *info, const char *passwd);
 void linphone_auth_info_set_username(LinphoneAuthInfo *info, const char *username);
 void linphone_auth_info_set_userid(LinphoneAuthInfo *info, const char *userid);
+void linphone_auth_info_set_realm(LinphoneAuthInfo *info, const char *realm);
+void linphone_auth_info_set_ha1(LinphoneAuthInfo *info, const char *ha1);
 
 const char *linphone_auth_info_get_username(const LinphoneAuthInfo *i);
 const char *linphone_auth_info_get_passwd(const LinphoneAuthInfo *i);
 const char *linphone_auth_info_get_userid(const LinphoneAuthInfo *i);
+const char *linphone_auth_info_get_realm(const LinphoneAuthInfo *i);
+const char *linphone_auth_info_get_ha1(const LinphoneAuthInfo *i);
 
 /* you don't need those function*/
 void linphone_auth_info_destroy(LinphoneAuthInfo *info);
@@ -662,20 +685,29 @@ typedef enum _LinphoneChatMessageStates {
  */
 typedef void (*LinphoneChatMessageStateChangeCb)(LinphoneChatMessage* msg,LinphoneChatMessageState state,void* ud);
 
+void linphone_core_set_chat_database_path(LinphoneCore *lc, const char *path);
 LinphoneChatRoom * linphone_core_create_chat_room(LinphoneCore *lc, const char *to);
+LinphoneChatRoom *linphone_core_get_chat_room(LinphoneCore *lc, const LinphoneAddress *addr);
 void linphone_chat_room_destroy(LinphoneChatRoom *cr);
 LinphoneChatMessage* linphone_chat_room_create_message(LinphoneChatRoom *cr,const char* message);
 const LinphoneAddress* linphone_chat_room_get_peer_address(LinphoneChatRoom *cr);
 void linphone_chat_room_send_message(LinphoneChatRoom *cr, const char *msg);
 void linphone_chat_room_send_message2(LinphoneChatRoom *cr, LinphoneChatMessage* msg,LinphoneChatMessageStateChangeCb status_cb,void* ud);
+MSList *linphone_chat_room_get_history(LinphoneChatRoom *cr,int nb_message);
+void linphone_chat_room_mark_as_read(LinphoneChatRoom *cr);
+void linphone_chat_room_delete_history(LinphoneChatRoom *cr);
+int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *cr);
 LinphoneCore* linphone_chat_room_get_lc(LinphoneChatRoom *cr);
 void linphone_chat_room_set_user_data(LinphoneChatRoom *cr, void * ud);
 void * linphone_chat_room_get_user_data(LinphoneChatRoom *cr);
 
+LinphoneChatMessageState linphone_chat_message_get_state(const LinphoneChatMessage* message);
 const char* linphone_chat_message_state_to_string(const LinphoneChatMessageState state);
 LinphoneChatMessage* linphone_chat_message_clone(const LinphoneChatMessage* message);
+void linphone_chat_message_destroy(LinphoneChatMessage* msg);
 void linphone_chat_message_set_from(LinphoneChatMessage* message, const LinphoneAddress* from);
-LinphoneAddress* linphone_chat_message_get_from(const LinphoneChatMessage* message);
+const LinphoneAddress* linphone_chat_message_get_from(const LinphoneChatMessage* message);
+const LinphoneAddress* linphone_chat_message_get_to(const LinphoneChatMessage* message);
 const char* linphone_chat_message_get_external_body_url(const LinphoneChatMessage* message);
 void linphone_chat_message_set_external_body_url(LinphoneChatMessage* message,const char* url);
 const char * linphone_chat_message_get_text(const LinphoneChatMessage* message);
@@ -684,6 +716,7 @@ void* linphone_chat_message_get_user_data(const LinphoneChatMessage* message);
 void linphone_chat_message_set_user_data(LinphoneChatMessage* message,void*);
 LinphoneChatRoom* linphone_chat_message_get_chat_room(LinphoneChatMessage *msg);
 const LinphoneAddress* linphone_chat_message_get_peer_address(LinphoneChatMessage *msg);
+LinphoneAddress *linphone_chat_message_get_local_address(const LinphoneChatMessage* message);
 void linphone_chat_message_add_custom_header(LinphoneChatMessage* message, const char *header_name, const char *header_value);
 const char * linphone_chat_message_get_custom_header(LinphoneChatMessage* message, const char *header_name);
 
@@ -841,6 +874,35 @@ typedef void * (*LinphoneWaitingCallback)(struct _LinphoneCore *lc, void *contex
 
 /* THE main API */
 
+/**
+ * Define a log handler.
+ *
+ * @ingroup misc
+ *
+ * @param logfunc The function pointer of the log handler.
+ */
+void linphone_core_set_log_handler(OrtpLogFunc logfunc);
+/**
+ * Define a log file.
+ *
+ * @ingroup misc
+ *
+ * If the file pointer passed as an argument is NULL, stdout is used instead.
+ *
+ * @param file A pointer to the FILE structure of the file to write to.
+ */
+void linphone_core_set_log_file(FILE *file);
+/**
+ * Define the log level.
+ *
+ * @ingroup misc
+ *
+ * The loglevel parameter is a bitmask parameter. Therefore to enable only warning and error
+ * messages, use ORTP_WARNING | ORTP_ERROR. To disable logs, simply set loglevel to 0.
+ *
+ * @param loglevel A bitmask of the log levels to set.
+ */
+void linphone_core_set_log_level(OrtpLogLevel loglevel);
 void linphone_core_enable_logs(FILE *file);
 void linphone_core_enable_logs_with_cb(OrtpLogFunc logfunc);
 void linphone_core_disable_logs(void);
@@ -851,6 +913,20 @@ const char *linphone_core_get_user_agent_version(void);
 LinphoneCore *linphone_core_new(const LinphoneCoreVTable *vtable,
                                                const char *config_path, const char *factory_config, void* userdata);
 
+/**
+ * Instantiates a LinphoneCore object with a given LpConfig.
+ * @ingroup initializing
+ *
+ * The LinphoneCore object is the primary handle for doing all phone actions.
+ * It should be unique within your application.
+ * @param vtable a LinphoneCoreVTable structure holding your application callbacks
+ * @param config a pointer to an LpConfig object holding the configuration of the LinphoneCore to be instantiated.
+ * @param userdata an opaque user pointer that can be retrieved at any time (for example in
+ *        callbacks) using linphone_core_get_user_data().
+ * @see linphone_core_new
+**/
+LinphoneCore *linphone_core_new_with_config(const LinphoneCoreVTable *vtable, struct _LpConfig *config, void *userdata);
+
 /* function to be periodically called in a main loop */
 /* For ICE to work properly it should be called every 20ms */
 void linphone_core_iterate(LinphoneCore *lc);
@@ -919,7 +995,12 @@ int linphone_core_update_call(LinphoneCore *lc, LinphoneCall *call, const Linpho
 int linphone_core_defer_call_update(LinphoneCore *lc, LinphoneCall *call);
 
 int linphone_core_accept_call_update(LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params);
-
+/**
+ * @ingroup media_parameters
+ * Get default call parameters reflecting current linphone core configuration
+ * @param LinphoneCore object
+ * @return  LinphoneCallParams
+ */
 LinphoneCallParams *linphone_core_create_default_call_parameters(LinphoneCore *lc);
 
 LinphoneCall *linphone_core_get_call_by_remote_address(LinphoneCore *lc, const char *remote_address);
@@ -967,16 +1048,23 @@ const MSList *linphone_core_get_video_codecs(const LinphoneCore *lc);
 int linphone_core_set_video_codecs(LinphoneCore *lc, MSList *codecs);
 
 bool_t linphone_core_payload_type_enabled(LinphoneCore *lc, const PayloadType *pt);
-
+/**
+ * Enable payload type
+ * @param linphone core
+ * @param pt payload type to enable, can be retrieve from #linphone_core_find_payload_type
+ * @param TRUE if enabled
+ * @return 0 if succed
+ *
+ */
 int linphone_core_enable_payload_type(LinphoneCore *lc, PayloadType *pt, bool_t enable);
 
 /**
- * Wildcard value used by #linphone_core_find_payload_type to ignore rate in search algirithm
+ * 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 algirithm
+ * 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
@@ -1111,10 +1199,9 @@ const char * linphone_core_get_stun_server(const LinphoneCore *lc);
  * @ingroup network_parameters
  * Return the availability of uPnP.
  *
- * @param lc #LinphoneCore
  * @return true if uPnP is available otherwise return false. 
  */
-bool_t linphone_core_upnp_available(const LinphoneCore *lc);
+bool_t linphone_core_upnp_available();
 
 /**
  * @ingroup network_parameters
@@ -1267,6 +1354,17 @@ void linphone_core_use_preview_window(LinphoneCore *lc, bool_t yesno);
 int linphone_core_get_device_rotation(LinphoneCore *lc );
 void linphone_core_set_device_rotation(LinphoneCore *lc, int rotation);
 
+/**
+ * @brief 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
+ */
+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);
 
@@ -1355,7 +1453,13 @@ void linphone_core_refresh_registers(LinphoneCore* lc);
 /* Path to the file storing secrets cache */
 void linphone_core_set_zrtp_secrets_file(LinphoneCore *lc, const char* file);
 const char *linphone_core_get_zrtp_secrets_file(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
+ */
 const LinphoneCall* linphone_core_find_call_from_uri(LinphoneCore *lc, const char *uri);
 
 int linphone_core_add_to_conference(LinphoneCore *lc, LinphoneCall *call);
@@ -1370,8 +1474,19 @@ int linphone_core_terminate_conference(LinphoneCore *lc);
 int linphone_core_get_conference_size(LinphoneCore *lc);
 int linphone_core_start_conference_recording(LinphoneCore *lc, const char *path);
 int linphone_core_stop_conference_recording(LinphoneCore *lc);
-
+/**
+ * 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
+ */
 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
+ */
 void linphone_core_set_max_calls(LinphoneCore *lc, int max);
 
 bool_t linphone_core_sound_resources_locked(LinphoneCore *lc);
@@ -1417,7 +1532,6 @@ void linphone_core_set_video_dscp(LinphoneCore *lc, int dscp);
 int linphone_core_get_video_dscp(const LinphoneCore *lc);
 
 
-
 #ifdef __cplusplus
 }
 #endif