linphonecore.h 59.7 KB
Newer Older
aymeric's avatar
aymeric committed
1 2
/*
linphone
3
Copyright (C) 2000 - 2010 Simon MORLAT (simon.morlat@linphone.org)
aymeric's avatar
aymeric committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

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"
smorlat's avatar
smorlat committed
25
#include "mediastreamer2/msvideo.h"
26 27

#ifdef IN_LINPHONE
smorlat's avatar
smorlat committed
28
#include "sipsetup.h"
29 30 31
#else
#include "linphone/sipsetup.h"
#endif
aymeric's avatar
aymeric committed
32

smorlat's avatar
smorlat committed
33
#define LINPHONE_IPADDR_SIZE 64
smorlat's avatar
smorlat committed
34
#define LINPHONE_HOSTNAME_SIZE 128
smorlat's avatar
smorlat committed
35

aymeric's avatar
aymeric committed
36 37 38 39 40 41
#ifdef __cplusplus
extern "C" {
#endif

struct _MSSndCard;
struct _LinphoneCore;
jehan's avatar
jehan committed
42 43 44 45 46
/**
 * Linphone core main object created by function linphone_core_new() .
 * @ingroup initializing
 */
typedef struct _LinphoneCore LinphoneCore;
47
struct SalOp;
aymeric's avatar
aymeric committed
48 49 50

struct _LpConfig;

51

52 53 54 55 56 57 58 59 60
struct _LCSipTransports{
	int udp_port;
	int tcp_port;
	int dtls_port;
	int tls_port;
};

typedef struct _LCSipTransports LCSipTransports;

smorlat's avatar
smorlat committed
61 62 63 64 65 66 67 68 69 70
/**
 * 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 <sip:alice@example.net>'.
 * 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.
71
 *
smorlat's avatar
smorlat committed
72 73 74
 * @ingroup linphone_address
 * @var LinphoneAddress
 */
75
typedef struct SalAddress LinphoneAddress;
jehan's avatar
jehan committed
76 77 78 79 80
#ifdef IN_LINPHONE
#include "linphonefriend.h"
#else
#include "linphone/linphonefriend.h"
#endif
81 82 83 84 85 86 87

LinphoneAddress * linphone_address_new(const char *uri);
LinphoneAddress * linphone_address_clone(const LinphoneAddress *uri);
const char *linphone_address_get_scheme(const LinphoneAddress *u);
const char *linphone_address_get_display_name(const LinphoneAddress* u);
const char *linphone_address_get_username(const LinphoneAddress *u);
const char *linphone_address_get_domain(const LinphoneAddress *u);
jehan's avatar
jehan committed
88 89 90 91 92 93 94 95 96
/**
 * Get port number as an integer value.
 *
 */
int linphone_address_get_port_int(const LinphoneAddress *u);
/**
 * Get port number, null if not present.
 */
const char* linphone_address_get_port(const LinphoneAddress *u);
97 98 99 100 101
void linphone_address_set_display_name(LinphoneAddress *u, const char *display_name);
void linphone_address_set_username(LinphoneAddress *uri, const char *username);
void linphone_address_set_domain(LinphoneAddress *uri, const char *host);
void linphone_address_set_port(LinphoneAddress *uri, const char *port);
void linphone_address_set_port_int(LinphoneAddress *uri, int port);
102
/*remove tags, params etc... so that it is displayable to the user*/
103 104 105
void linphone_address_clean(LinphoneAddress *uri);
char *linphone_address_as_string(const LinphoneAddress *u);
char *linphone_address_as_string_uri_only(const LinphoneAddress *u);
106
bool_t linphone_address_weak_equal(const LinphoneAddress *a1, const LinphoneAddress *a2);
107
void linphone_address_destroy(LinphoneAddress *u);
aymeric's avatar
aymeric committed
108

smorlat's avatar
smorlat committed
109
struct _SipSetupContext;
110

aymeric's avatar
aymeric committed
111

smorlat's avatar
smorlat committed
112 113 114 115 116 117 118 119
/**
 * Enum representing the direction of a call.
 * @ingroup call_logs
**/
enum _LinphoneCallDir {
	LinphoneCallOutgoing, /**< outgoing calls*/
	LinphoneCallIncoming  /**< incoming calls*/
};
aymeric's avatar
aymeric committed
120

smorlat's avatar
smorlat committed
121 122 123 124 125
/**
 * Typedef for enum
 * @ingroup call_logs
**/
typedef enum _LinphoneCallDir LinphoneCallDir;
aymeric's avatar
aymeric committed
126

smorlat's avatar
smorlat committed
127 128 129 130
/**
 * Enum representing the status of a call
 * @ingroup call_logs
**/
131
typedef enum _LinphoneCallStatus {
smorlat's avatar
smorlat committed
132 133
	LinphoneCallSuccess, /**< The call was sucessful*/
	LinphoneCallAborted, /**< The call was aborted */
134 135
	LinphoneCallMissed, /**< The call was missed (unanswered)*/
	LinphoneCallDeclined /**< The call was declined, either locally or by remote end*/
aymeric's avatar
aymeric committed
136 137
} LinphoneCallStatus;

smorlat's avatar
smorlat committed
138 139 140 141
/**
 * Structure representing a call log.
 *
 * @ingroup call_logs
142
 *
smorlat's avatar
smorlat committed
143
**/
aymeric's avatar
aymeric committed
144
typedef struct _LinphoneCallLog{
smorlat's avatar
smorlat committed
145 146 147 148
	LinphoneCallDir dir; /**< The direction of the call*/
	LinphoneCallStatus status; /**< The status of the call*/
	LinphoneAddress *from; /**<Originator of the call as a LinphoneAddress object*/
	LinphoneAddress *to; /**<Destination of the call as a LinphoneAddress object*/
jehan's avatar
jehan committed
149
	char start_date[128]; /**<Human readable string containing the start date*/
smorlat's avatar
smorlat committed
150
	int duration; /**<Duration of the call in seconds*/
151
	char *refkey;
smorlat's avatar
smorlat committed
152
	void *user_pointer;
153 154
	rtp_stats_t local_stats;
	rtp_stats_t remote_stats;
155
	float quality;
156
    int video_enabled;
157
	struct _LinphoneCore *lc;
158
	time_t start_date_time; /**Start date of the call in seconds as expressed in a time_t */
jehan's avatar
jehan committed
159
	const char* call_id; /**unique id of a call*/
aymeric's avatar
aymeric committed
160 161
} LinphoneCallLog;

Simon Morlat's avatar
Simon Morlat committed
162 163 164 165

/**
 * Enum describing type of media encryption types.
**/
166 167 168 169 170
enum LinphoneMediaEncryption {
	LinphoneMediaEncryptionNone,
	LinphoneMediaEncryptionSRTP,
	LinphoneMediaEncryptionZRTP
};
smorlat's avatar
smorlat committed
171

Simon Morlat's avatar
Simon Morlat committed
172 173 174
/**
 * Enum describing type of media encryption types.
**/
175
typedef enum LinphoneMediaEncryption LinphoneMediaEncryption;
aymeric's avatar
aymeric committed
176 177

/*public: */
smorlat's avatar
smorlat committed
178 179
void linphone_call_log_set_user_pointer(LinphoneCallLog *cl, void *up);
void *linphone_call_log_get_user_pointer(const LinphoneCallLog *cl);
180 181
void linphone_call_log_set_ref_key(LinphoneCallLog *cl, const char *refkey);
const char *linphone_call_log_get_ref_key(const LinphoneCallLog *cl);
182 183
const rtp_stats_t *linphone_call_log_get_local_stats(const LinphoneCallLog *cl);
const rtp_stats_t *linphone_call_log_get_remote_stats(const LinphoneCallLog *cl);
aymeric's avatar
aymeric committed
184 185
char * linphone_call_log_to_str(LinphoneCallLog *cl);

Simon Morlat's avatar
Simon Morlat committed
186
struct _LinphoneCallParams;
187

188
/**
Guillaume Beraudo's avatar
Typo  
Guillaume Beraudo committed
189
 * The LinphoneCallParams is an object containing various call related parameters.
190
 * It can be used to retrieve parameters from a currently running call or modify the call's characteristics
191 192 193 194
 * dynamically.
**/
typedef struct _LinphoneCallParams LinphoneCallParams;

195 196
const PayloadType* linphone_call_params_get_used_audio_codec(const LinphoneCallParams *cp);
const PayloadType* linphone_call_params_get_used_video_codec(const LinphoneCallParams *cp);
197
LinphoneCallParams * linphone_call_params_copy(const LinphoneCallParams *cp);
198
void linphone_call_params_enable_video(LinphoneCallParams *cp, bool_t enabled);
199
bool_t linphone_call_params_video_enabled(const LinphoneCallParams *cp);
Simon Morlat's avatar
Simon Morlat committed
200 201
LinphoneMediaEncryption linphone_call_params_get_media_encryption(const LinphoneCallParams *cp);
void linphone_call_params_set_media_encryption(LinphoneCallParams *cp, LinphoneMediaEncryption e);
202 203
void linphone_call_params_enable_early_media_sending(LinphoneCallParams *cp, bool_t enabled);
bool_t linphone_call_params_early_media_sending_enabled(const LinphoneCallParams *cp);
Simon Morlat's avatar
Simon Morlat committed
204
bool_t linphone_call_params_local_conference_mode(const LinphoneCallParams *cp);
205
void linphone_call_params_set_audio_bandwidth_limit(LinphoneCallParams *cp, int bw);
206
void linphone_call_params_destroy(LinphoneCallParams *cp);
jehan's avatar
jehan committed
207
bool_t linphone_call_params_low_bandwidth_enabled(const LinphoneCallParams *cp);
208 209
void linphone_call_params_enable_low_bandwidth(LinphoneCallParams *cp, bool_t enabled);

Simon Morlat's avatar
Simon Morlat committed
210 211
/**
 * Enum describing failure reasons.
Simon Morlat's avatar
Simon Morlat committed
212
 * @ingroup initializing
Simon Morlat's avatar
Simon Morlat committed
213
**/
214 215 216 217 218
enum _LinphoneReason{
	LinphoneReasonNone,
	LinphoneReasonNoResponse, /**<No response received from remote*/
	LinphoneReasonBadCredentials, /**<Authentication failed due to bad or missing credentials*/
	LinphoneReasonDeclined, /**<The call has been declined*/
219
	LinphoneReasonNotFound, /**<Destination of the calls was not found.*/
220 221
	LinphoneReasonNotAnswered, /**<The call was not answered in time*/
	LinphoneReasonBusy /**<Phone line was busy */
Simon Morlat's avatar
Simon Morlat committed
222 223
};

Simon Morlat's avatar
Simon Morlat committed
224 225 226 227
/**
 * Enum describing failure reasons.
 * @ingroup initializing
**/
228
typedef enum _LinphoneReason LinphoneReason;
Simon Morlat's avatar
Simon Morlat committed
229

230
const char *linphone_reason_to_string(LinphoneReason err);
Simon Morlat's avatar
Simon Morlat committed
231

232 233
/**
 * Structure describing policy regarding video streams establishments.
Simon Morlat's avatar
Simon Morlat committed
234
 * @ingroup media_parameters
235 236 237 238 239 240 241
**/
struct _LinphoneVideoPolicy{
	bool_t automatically_initiate; /**<Whether video shall be automatically proposed for outgoing calls.*/ 
	bool_t automatically_accept; /**<Whether video shall be automatically accepted for incoming calls*/
	bool_t unused[2];
};

Simon Morlat's avatar
Simon Morlat committed
242 243 244 245
/**
 * Structure describing policy regarding video streams establishments.
 * @ingroup media_parameters
**/
246 247
typedef struct _LinphoneVideoPolicy LinphoneVideoPolicy;

248 249
/**
 * The LinphoneCall object represents a call issued or received by the LinphoneCore
Simon Morlat's avatar
Simon Morlat committed
250
 * @ingroup call_control
251 252
**/
struct _LinphoneCall;
253 254
/**
 * The LinphoneCall object represents a call issued or received by the LinphoneCore
Simon Morlat's avatar
Simon Morlat committed
255
 * @ingroup call_control
256
**/
257
typedef struct _LinphoneCall LinphoneCall;
Yann Diorcet's avatar
Yann Diorcet committed
258 259


Simon Morlat's avatar
Simon Morlat committed
260 261 262 263 264
/**
 * @addtogroup call_misc
 * @{
**/

Yann Diorcet's avatar
Yann Diorcet committed
265 266 267
#define LINPHONE_CALL_STATS_AUDIO 0
#define LINPHONE_CALL_STATS_VIDEO 1

268 269 270 271 272 273
/**
 * Enum describing ICE states.
 * @ingroup initializing
**/
enum _LinphoneIceState{
	LinphoneIceStateNotActivated, /**< ICE has not been activated for this call */
Ghislain MARY's avatar
Ghislain MARY committed
274
	LinphoneIceStateFailed, /**< ICE processing has failed */
275 276 277 278 279 280 281 282 283 284 285 286
	LinphoneIceStateInProgress, /**< ICE process is in progress */
	LinphoneIceStateHostConnection, /**< ICE has established a direct connection to the remote host */
	LinphoneIceStateReflexiveConnection, /**< ICE has established a connection to the remote host through one or several NATs */
	LinphoneIceStateRelayConnection /**< ICE has established a connection through a relay */
};

/**
 * Enum describing Ice states.
 * @ingroup initializing
**/
typedef enum _LinphoneIceState LinphoneIceState;

Simon Morlat's avatar
Simon Morlat committed
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
/**
 * The LinphoneCallStats objects carries various statistic informations regarding quality of audio or video streams.
 *
 * To receive these informations periodically and as soon as they are computed, the application is invited to place a #CallStatsUpdated callback in the LinphoneCoreVTable structure
 * it passes for instanciating the LinphoneCore object (see linphone_core_new() ).
 *
 * At any time, the application can access last computed statistics using linphone_call_get_audio_stats() or linphone_call_get_video_stats().
**/
typedef struct _LinphoneCallStats LinphoneCallStats;

/**
 * The LinphoneCallStats objects carries various statistic informations regarding quality of audio or video streams.
 *
 * To receive these informations periodically and as soon as they are computed, the application is invited to place a #CallStatsUpdated callback in the LinphoneCoreVTable structure
 * it passes for instanciating the LinphoneCore object (see linphone_core_new() ).
 *
 * At any time, the application can access last computed statistics using linphone_call_get_audio_stats() or linphone_call_get_video_stats().
**/
struct _LinphoneCallStats {
	int		type; /**< Can be either LINPHONE_CALL_STATS_AUDIO or LINPHONE_CALL_STATS_VIDEO*/
	jitter_stats_t	jitter_stats; /**<jitter buffer statistics, see oRTP documentation for details */
	mblk_t*		received_rtcp; /**<Last RTCP packet received, as a mblk_t structure. See oRTP documentation for details how to extract information from it*/
	mblk_t*		sent_rtcp;/**<Last RTCP packet sent, as a mblk_t structure. See oRTP documentation for details how to extract information from it*/
	float		round_trip_delay; /**<Round trip propagation time in seconds if known, -1 if unknown.*/
311
	LinphoneIceState	ice_state; /**< State of ICE processing. */
312 313
	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*/
Simon Morlat's avatar
Simon Morlat committed
314 315 316 317 318
};

/**
 * @}
**/
Yann Diorcet's avatar
Yann Diorcet committed
319 320 321 322 323

const LinphoneCallStats *linphone_call_get_audio_stats(const LinphoneCall *call);
const LinphoneCallStats *linphone_call_get_video_stats(const LinphoneCall *call);


324 325
/** Callback prototype */
typedef void (*LinphoneCallCbFunc)(struct _LinphoneCall *call,void * user_data);
326

Simon Morlat's avatar
Simon Morlat committed
327 328 329 330 331
/**
 * LinphoneCallState enum represents the different state a call can reach into.
 * The application is notified of state changes through the LinphoneCoreVTable::call_state_changed callback.
 * @ingroup call_control
**/
332
typedef enum _LinphoneCallState{
Simon Morlat's avatar
Simon Morlat committed
333
	LinphoneCallIdle,					/**<Initial call state */
334 335 336 337 338 339 340 341 342 343 344 345 346 347
	LinphoneCallIncomingReceived, /**<This is a new incoming call */
	LinphoneCallOutgoingInit, /**<An outgoing call is started */
	LinphoneCallOutgoingProgress, /**<An outgoing call is in progress */
	LinphoneCallOutgoingRinging, /**<An outgoing call is ringing at remote end */
	LinphoneCallOutgoingEarlyMedia, /**<An outgoing call is proposed early media */
	LinphoneCallConnected, /**<Connected, the call is answered */
	LinphoneCallStreamsRunning, /**<The media streams are established and running*/
	LinphoneCallPausing, /**<The call is pausing at the initiative of local end */
	LinphoneCallPaused, /**< The call is paused, remote end has accepted the pause */
	LinphoneCallResuming, /**<The call is being resumed by local end*/
	LinphoneCallRefered, /**<The call is being transfered to another party, resulting in a new outgoing call to follow immediately*/
	LinphoneCallError, /**<The call encountered an error*/
	LinphoneCallEnd, /**<The call ended normally*/
	LinphoneCallPausedByRemote, /**<The call is paused by remote end*/
Simon Morlat's avatar
Simon Morlat committed
348
	LinphoneCallUpdatedByRemote, /**<The call's parameters change is requested by remote end, used for example when video is added by remote */
349
	LinphoneCallIncomingEarlyMedia, /**<We are proposing early media to an incoming call */
350
	LinphoneCallUpdating, /**<A call update has been initiated by us */
351
	LinphoneCallReleased /**< The call object is no more retained by the core */
352 353
} LinphoneCallState;

354
const char *linphone_call_state_to_string(LinphoneCallState cs);
355

356
LinphoneCore *linphone_call_get_core(const LinphoneCall *call);
357
LinphoneCallState linphone_call_get_state(const LinphoneCall *call);
358 359 360 361
bool_t linphone_call_asked_to_autoanswer(LinphoneCall *call);
const LinphoneAddress * linphone_core_get_current_call_remote_address(struct _LinphoneCore *lc);
const LinphoneAddress * linphone_call_get_remote_address(const LinphoneCall *call);
char *linphone_call_get_remote_address_as_string(const LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
362
LinphoneCallDir linphone_call_get_dir(const LinphoneCall *call);
363
LinphoneCall * linphone_call_ref(LinphoneCall *call);
364 365
void linphone_call_unref(LinphoneCall *call);
LinphoneCallLog *linphone_call_get_call_log(const LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
366
const char *linphone_call_get_refer_to(const LinphoneCall *call);
367
bool_t linphone_call_has_transfer_pending(const LinphoneCall *call);
368
LinphoneCall *linphone_call_get_replaced_call(LinphoneCall *call);
369
int linphone_call_get_duration(const LinphoneCall *call);
370
const LinphoneCallParams * linphone_call_get_current_params(const LinphoneCall *call);
371
const LinphoneCallParams * linphone_call_get_remote_params(LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
372 373
void linphone_call_enable_camera(LinphoneCall *lc, bool_t enabled);
bool_t linphone_call_camera_enabled(const LinphoneCall *lc);
374
int linphone_call_take_video_snapshot(LinphoneCall *call, const char *file);
375
LinphoneReason linphone_call_get_reason(const LinphoneCall *call);
376
const char *linphone_call_get_remote_user_agent(LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
377 378
float linphone_call_get_play_volume(LinphoneCall *call);
float linphone_call_get_record_volume(LinphoneCall *call);
379 380
float linphone_call_get_current_quality(LinphoneCall *call);
float linphone_call_get_average_quality(LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
381 382
const char* linphone_call_get_authentication_token(LinphoneCall *call);
bool_t linphone_call_get_authentication_token_verified(LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
383
void linphone_call_set_authentication_token_verified(LinphoneCall *call, bool_t verified);
Simon Morlat's avatar
Simon Morlat committed
384
void linphone_call_send_vfu_request(LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
385 386
void *linphone_call_get_user_pointer(LinphoneCall *call);
void linphone_call_set_user_pointer(LinphoneCall *call, void *user_pointer);
387
void linphone_call_set_next_video_frame_decoded_callback(LinphoneCall *call, LinphoneCallCbFunc cb, void* user_data);
388
LinphoneCallState linphone_call_get_transfer_state(LinphoneCall *call);
389
void linphone_call_zoom_video(LinphoneCall* call, float zoom_factor, float* cx, float* cy);
jehan's avatar
jehan committed
390 391 392 393 394 395 396 397
/**
 * Return TRUE if this call is currently part of a conference
 *@param call #LinphoneCall
 *@return TRUE if part of a conference.
 *
 @ingroup call_control
 */
bool_t linphone_call_is_in_conference(const LinphoneCall *call);
jehan's avatar
jehan committed
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
/**
 * Enables or disable echo cancellation for this call
 * @param call
 * @param val
 *
 * @ingroup media_parameters
**/
void linphone_call_enable_echo_cancellation(LinphoneCall *call, bool_t val) ;
/**
 * Returns TRUE if echo cancellation is enabled.
 *
 * @ingroup media_parameters
**/
bool_t linphone_call_echo_cancellation_enabled(LinphoneCall *lc);
/**
 * Enables or disable echo limiter for this call
 * @param call
 * @param val
 *
 * @ingroup media_parameters
**/
void linphone_call_enable_echo_limiter(LinphoneCall *call, bool_t val);
/**
 * Returns TRUE if echo limiter is enabled.
 *
 * @ingroup media_parameters
**/
bool_t linphone_call_echo_limiter_enabled(const LinphoneCall *call);
Simon Morlat's avatar
Simon Morlat committed
426 427

/*keep this in sync with mediastreamer2/msvolume.h*/
Simon Morlat's avatar
Simon Morlat committed
428 429 430 431 432 433

/**
 * Lowest volume measurement that can be returned by linphone_call_get_play_volume() or linphone_call_get_record_volume(), corresponding to pure silence.
 * @ingroup call_misc
**/
#define LINPHONE_VOLUME_DB_LOWEST (-120)
Simon Morlat's avatar
Simon Morlat committed
434

smorlat's avatar
smorlat committed
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
/**
 * @addtogroup proxies
 * @{
**/
/**
 * The LinphoneProxyConfig object represents a proxy configuration to be used
 * by the LinphoneCore object.
 * Its fields must not be used directly in favour of the accessors methods.
 * Once created and filled properly the LinphoneProxyConfig can be given to
 * LinphoneCore with linphone_core_add_proxy_config().
 * This will automatically triggers the registration, if enabled.
 *
 * The proxy configuration are persistent to restarts because they are saved
 * in the configuration file. As a consequence, after linphone_core_new() there
 * might already be a list of configured proxy that can be examined with
 * linphone_core_get_proxy_config_list().
 *
 * The default proxy (see linphone_core_set_default_proxy() ) is the one of the list
 * that is used by default for calls.
**/
455
typedef struct _LinphoneProxyConfig LinphoneProxyConfig;
aymeric's avatar
aymeric committed
456

457 458 459 460
/**
 * LinphoneRegistrationState describes proxy registration states.
**/
typedef enum _LinphoneRegistrationState{
Simon Morlat's avatar
Simon Morlat committed
461 462 463 464 465
	LinphoneRegistrationNone, /**<Initial state for registrations */
	LinphoneRegistrationProgress, /**<Registration is in progress */
	LinphoneRegistrationOk,	/**< Registration is successful */
	LinphoneRegistrationCleared, /**< Unregistration succeeded */
	LinphoneRegistrationFailed	/**<Registration failed */
466 467
}LinphoneRegistrationState;

jehan's avatar
jehan committed
468 469 470 471
/**
 * Human readable version of the #LinphoneRegistrationState
 * @param cs sate
 */
472 473
const char *linphone_registration_state_to_string(LinphoneRegistrationState cs);

aymeric's avatar
aymeric committed
474 475
LinphoneProxyConfig *linphone_proxy_config_new(void);
int linphone_proxy_config_set_server_addr(LinphoneProxyConfig *obj, const char *server_addr);
476 477
int linphone_proxy_config_set_identity(LinphoneProxyConfig *obj, const char *identity);
int linphone_proxy_config_set_route(LinphoneProxyConfig *obj, const char *route);
Simon Morlat's avatar
Simon Morlat committed
478
void linphone_proxy_config_expires(LinphoneProxyConfig *obj, int expires);
jehan's avatar
jehan committed
479 480 481 482 483 484
/**
 * Indicates  either or not, REGISTRATION must be issued for this #LinphoneProxyConfig .
 * <br> In case this #LinphoneProxyConfig has been added to #LinphoneCore, follows the linphone_proxy_config_edit() rule.
 * @param obj object pointer
 * @param val if true, registration will be engaged
 */
aymeric's avatar
aymeric committed
485 486 487 488
void linphone_proxy_config_enable_register(LinphoneProxyConfig *obj, bool_t val);
#define linphone_proxy_config_enableregister linphone_proxy_config_enable_register
void linphone_proxy_config_edit(LinphoneProxyConfig *obj);
int linphone_proxy_config_done(LinphoneProxyConfig *obj);
jehan's avatar
jehan committed
489 490 491 492 493 494 495
/**
 * Indicates  either or not, PUBLISH must be issued for this #LinphoneProxyConfig .
 * <br> In case this #LinphoneProxyConfig has been added to #LinphoneCore, follows the linphone_proxy_config_edit() rule.
 * @param obj object pointer
 * @param val if true, publish will be engaged
 *
 */
aymeric's avatar
aymeric committed
496
void linphone_proxy_config_enable_publish(LinphoneProxyConfig *obj, bool_t val);
497 498 499
void linphone_proxy_config_set_dial_escape_plus(LinphoneProxyConfig *cfg, bool_t val);
void linphone_proxy_config_set_dial_prefix(LinphoneProxyConfig *cfg, const char *prefix);

500
LinphoneRegistrationState linphone_proxy_config_get_state(const LinphoneProxyConfig *obj);
smorlat's avatar
smorlat committed
501
bool_t linphone_proxy_config_is_registered(const LinphoneProxyConfig *obj);
smorlat's avatar
smorlat committed
502
const char *linphone_proxy_config_get_domain(const LinphoneProxyConfig *cfg);
503 504 505 506 507 508 509

const char *linphone_proxy_config_get_route(const LinphoneProxyConfig *obj);
const char *linphone_proxy_config_get_identity(const LinphoneProxyConfig *obj);
bool_t linphone_proxy_config_publish_enabled(const LinphoneProxyConfig *obj);
const char *linphone_proxy_config_get_addr(const LinphoneProxyConfig *obj);
int linphone_proxy_config_get_expires(const LinphoneProxyConfig *obj);
bool_t linphone_proxy_config_register_enabled(const LinphoneProxyConfig *obj);
510
void linphone_proxy_config_refresh_register(LinphoneProxyConfig *obj);
511 512
const char *linphone_proxy_config_get_contact_parameters(const LinphoneProxyConfig *obj);
void linphone_proxy_config_set_contact_parameters(LinphoneProxyConfig *obj, const char *contact_params);
513 514
struct _LinphoneCore * linphone_proxy_config_get_core(const LinphoneProxyConfig *obj);

515 516 517
bool_t linphone_proxy_config_get_dial_escape_plus(const LinphoneProxyConfig *cfg);
const char * linphone_proxy_config_get_dial_prefix(const LinphoneProxyConfig *cfg);

518
LinphoneReason linphone_proxy_config_get_error(const LinphoneProxyConfig *cfg);
Simon Morlat's avatar
Simon Morlat committed
519

aymeric's avatar
aymeric committed
520 521
/* destruction is called automatically when removing the proxy config */
void linphone_proxy_config_destroy(LinphoneProxyConfig *cfg);
smorlat's avatar
smorlat committed
522 523
void linphone_proxy_config_set_sip_setup(LinphoneProxyConfig *cfg, const char *type);
SipSetupContext *linphone_proxy_config_get_sip_setup_context(LinphoneProxyConfig *cfg);
524
SipSetup *linphone_proxy_config_get_sip_setup(LinphoneProxyConfig *cfg);
525 526 527 528
/**
 * normalize a human readable phone number into a basic string. 888-444-222 becomes 888444222
 */
int linphone_proxy_config_normalize_number(LinphoneProxyConfig *proxy, const char *username, char *result, size_t result_len);
jehan's avatar
jehan committed
529 530 531 532 533 534 535 536
/*
 *  attached a user data to a proxy config
 */
void linphone_proxy_config_set_user_data(LinphoneProxyConfig *cr, void * ud);
/*
 *  get user data to a proxy config. return null if any
 */
void * linphone_proxy_config_get_user_data(LinphoneProxyConfig *cr);
smorlat's avatar
smorlat committed
537

smorlat's avatar
smorlat committed
538 539 540 541
/**
 * @}
**/

smorlat's avatar
smorlat committed
542 543 544 545 546 547
typedef struct _LinphoneAccountCreator{
	struct _LinphoneCore *lc;
	struct _SipSetupContext *ssctx;
	char *username;
	char *password;
	char *domain;
Sylvain Berfini's avatar
Wizard  
Sylvain Berfini committed
548 549 550
	char *route;
	char *email;
	int suscribe;
smorlat's avatar
smorlat committed
551 552 553
	bool_t succeeded;
}LinphoneAccountCreator;

554
LinphoneAccountCreator *linphone_account_creator_new(struct _LinphoneCore *core, const char *type);
smorlat's avatar
smorlat committed
555 556 557
void linphone_account_creator_set_username(LinphoneAccountCreator *obj, const char *username);
void linphone_account_creator_set_password(LinphoneAccountCreator *obj, const char *password);
void linphone_account_creator_set_domain(LinphoneAccountCreator *obj, const char *domain);
Sylvain Berfini's avatar
Wizard  
Sylvain Berfini committed
558 559 560
void linphone_account_creator_set_route(LinphoneAccountCreator *obj, const char *route);
void linphone_account_creator_set_email(LinphoneAccountCreator *obj, const char *email);
void linphone_account_creator_set_suscribe(LinphoneAccountCreator *obj, int suscribre);
smorlat's avatar
smorlat committed
561 562
const char * linphone_account_creator_get_username(LinphoneAccountCreator *obj);
const char * linphone_account_creator_get_domain(LinphoneAccountCreator *obj);
563
int linphone_account_creator_test_existence(LinphoneAccountCreator *obj);
Sylvain Berfini's avatar
Wizard  
Sylvain Berfini committed
564
int linphone_account_creator_test_validation(LinphoneAccountCreator *obj);
smorlat's avatar
smorlat committed
565 566 567
LinphoneProxyConfig * linphone_account_creator_validate(LinphoneAccountCreator *obj);
void linphone_account_creator_destroy(LinphoneAccountCreator *obj);

568 569
struct _LinphoneAuthInfo;

smorlat's avatar
smorlat committed
570 571 572 573 574 575 576 577 578 579 580 581
/**
 * @ingroup authentication
 * Object holding authentication information.
 *
 * @note The object's fields should not be accessed directly. Prefer using
 * the accessor methods.
 *
 * In most case, authentication information consists of a username and password.
 * Sometimes, a userid is required by proxy, and realm can be useful to discriminate
 * different SIP domains.
 *
 * Once created and filled, a LinphoneAuthInfo must be added to the LinphoneCore in
582
 * order to become known and used automatically when needed.
smorlat's avatar
smorlat committed
583 584 585 586 587 588
 * Use linphone_core_add_auth_info() for that purpose.
 *
 * The LinphoneCore object can take the initiative to request authentication information
 * when needed to the application through the auth_info_requested callback of the
 * LinphoneCoreVTable structure.
 *
589 590
 * The application can respond to this information request later using
 * linphone_core_add_auth_info(). This will unblock all pending authentication
smorlat's avatar
smorlat committed
591 592 593
 * transactions and retry them with authentication headers.
 *
**/
594
typedef struct _LinphoneAuthInfo LinphoneAuthInfo;
aymeric's avatar
aymeric committed
595 596 597 598

LinphoneAuthInfo *linphone_auth_info_new(const char *username, const char *userid,
		const char *passwd, const char *ha1,const char *realm);
void linphone_auth_info_set_passwd(LinphoneAuthInfo *info, const char *passwd);
smorlat's avatar
smorlat committed
599
void linphone_auth_info_set_username(LinphoneAuthInfo *info, const char *username);
600
void linphone_auth_info_set_userid(LinphoneAuthInfo *info, const char *userid);
601 602 603 604 605

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

aymeric's avatar
aymeric committed
606 607 608 609
/* you don't need those function*/
void linphone_auth_info_destroy(LinphoneAuthInfo *info);
LinphoneAuthInfo * linphone_auth_info_new_from_config_file(struct _LpConfig *config, int pos);

jehan's avatar
jehan committed
610

611
struct _LinphoneChatRoom;
jehan's avatar
jehan committed
612 613 614 615
/**
 * @addtogroup chatroom
 * @{
 */
jehan's avatar
jehan committed
616 617 618 619 620 621 622

/**
 * A chat room message to old content to be sent.
 * <br> Can be created by linphone_chat_room_create_message().
 */
typedef struct _LinphoneChatMessage LinphoneChatMessage;
	
jehan's avatar
jehan committed
623 624 625 626
/**
 * A chat room is the place where text messages are exchanged.
 * <br> Can be created by linphone_core_create_chat_room().
 */
aymeric's avatar
aymeric committed
627
typedef struct _LinphoneChatRoom LinphoneChatRoom;
jehan's avatar
jehan committed
628

jehan's avatar
jehan committed
629 630 631 632 633 634 635 636 637 638 639 640 641
/**
 * Create a new chat room for messaging from a sip uri like sip:joe@sip.linphone.org
 * @param lc #LinphoneCore object
 * @param to destination address for messages
 * @return #LinphoneChatRoom where messaging can take place.
 */
LinphoneChatRoom * linphone_core_create_chat_room(LinphoneCore *lc, const char *to);
/**
 * Destructor
 * @param cr #LinphoneChatRoom object
 */
void linphone_chat_room_destroy(LinphoneChatRoom *cr);

jehan's avatar
jehan committed
642 643 644 645 646
/**
 * create a message attached to a dedicated chat room;
 */
LinphoneChatMessage* linphone_chat_room_create_message(const LinphoneChatRoom *cr,const char* message);

aymeric's avatar
aymeric committed
647

jehan's avatar
jehan committed
648 649 650 651 652 653 654 655 656 657 658
/**
 * get peer address \link linphone_core_create_chat_room() associated to \endlink this #LinphoneChatRoom
 * @param cr #LinphoneChatRoom object
 * @return #LinphoneAddress peer address
 */
const LinphoneAddress* linphone_chat_room_get_peer_address(LinphoneChatRoom *cr);
/**
 * send a message to peer member of this chat room.
 * @param cr #LinphoneChatRoom object
 * @param msg message to be sent
 */
aymeric's avatar
aymeric committed
659
void linphone_chat_room_send_message(LinphoneChatRoom *cr, const char *msg);
jehan's avatar
jehan committed
660
/**
661
 *LinphoneChatMessageState is used to notify if messages have been succesfully delivered or not.
jehan's avatar
jehan committed
662 663
 */
typedef enum _LinphoneChatMessageStates {
664 665 666 667
	LinphoneChatMessageStateIdle, /**<initial state*/
	LinphoneChatMessageStateInProgress, /**<delivery in progress**/
	LinphoneChatMessageStateDelivered, /**<message succesffully delivered an acknoleged by remote end point*/
	LinphoneChatMessageStateNotDelivered /**<message was not delivered*/
jehan's avatar
jehan committed
668 669
}LinphoneChatMessageState;

670
	
jehan's avatar
jehan committed
671 672 673 674
/**
 * to string function
 */
const char* linphone_chat_message_state_to_string(const LinphoneChatMessageState state);
675

jehan's avatar
jehan committed
676
/**
677
 * Clone a chat message 
678 679
 *@param message #LinphoneChatMessage obj
 *@return #LinphoneChatMessage
jehan's avatar
jehan committed
680
 */
681 682
LinphoneChatMessage* linphone_chat_message_clone(const LinphoneChatMessage* message);
/**
683
 * Set origin of the message
684 685 686 687 688 689
 *@param message #LinphoneChatMessage obj
 *@param from #LinphoneAddress origin of this message (copied)
 */
void linphone_chat_message_set_from(LinphoneChatMessage* message, const LinphoneAddress* from);

/**
690
 * Get origin of the message 
691 692 693 694 695 696 697 698
 *@param message #LinphoneChatMessage obj
 *@return #LinphoneAddress
 */
LinphoneAddress* linphone_chat_message_get_from(const LinphoneChatMessage* message);
	
/**
 * Linphone message can carry external body as defined by rfc2017
 * @param message #LinphoneChatMessage
699
 * @return external body url or NULL if not present.
700 701 702 703 704 705
 */
const char* linphone_chat_message_get_external_body_url(const LinphoneChatMessage* message);
	
/**
 * Linphone message can carry external body as defined by rfc2017
 * 
706
 * @param message a LinphoneChatMessage  
707 708 709 710 711
 * @param url ex: access-type=URL; URL="http://www.foo.com/file"
 */
void linphone_chat_message_set_external_body_url(LinphoneChatMessage* message,const char* url);

/**
712 713
 * Get text part of this message
 * @return text or NULL if no text.
714 715
 */
const char * linphone_chat_message_get_text(const LinphoneChatMessage* message);	
jehan's avatar
jehan committed
716 717 718
/**
 * user pointer get function
 */
719

jehan's avatar
jehan committed
720
void* linphone_chat_message_get_user_data(const LinphoneChatMessage* message);
721 722 723 724
/**
 * user pointer set function
 */
void linphone_chat_message_set_user_data(LinphoneChatMessage* message,void*);
jehan's avatar
jehan committed
725 726 727 728
	
/**
 * Call back used to notify message delivery status
 *@param msg #LinphoneChatMessage object
729 730
 *@param status LinphoneChatMessageState
 *@param ud application user data
jehan's avatar
jehan committed
731 732 733 734 735 736
 */
typedef void (*LinphoneChatMessageStateChangeCb)(LinphoneChatMessage* msg,LinphoneChatMessageState state,void* ud);
/**
 * send a message to peer member of this chat room.
 * @param cr #LinphoneChatRoom object
 * @param msg #LinphoneChatMessage message to be sent
737
 * @param status_cb LinphoneChatMessageStateChangeCb status callback invoked when message is delivered or could not be delivered. May be NULL
jehan's avatar
jehan committed
738 739 740
 * @param ud user data for the status cb.
 */
void linphone_chat_room_send_message2(LinphoneChatRoom *cr, LinphoneChatMessage* msg,LinphoneChatMessageStateChangeCb status_cb,void* ud);
741 742
LinphoneCore* linphone_chat_room_get_lc(LinphoneChatRoom *cr);
LinphoneChatRoom* linphone_chat_message_get_chat_room(LinphoneChatMessage *msg);
743
char* linphone_chat_message_get_message(LinphoneChatMessage *msg);
744
const LinphoneAddress* linphone_chat_message_get_peer_address(LinphoneChatMessage *msg);
aymeric's avatar
aymeric committed
745 746 747
void linphone_chat_room_set_user_data(LinphoneChatRoom *cr, void * ud);
void * linphone_chat_room_get_user_data(LinphoneChatRoom *cr);

jehan's avatar
jehan committed
748 749 750
/**
 * @}
 */
Simon Morlat's avatar
Simon Morlat committed
751 752 753 754 755 756 757 758 759 760 761


/**
 * @addtogroup initializing
 * @{
**/

/**
 * LinphoneGlobalState describes the global state of the LinphoneCore object.
 * It is notified via the LinphoneCoreVTable::global_state_changed
**/
762 763 764 765 766 767 768
typedef enum _LinphoneGlobalState{
	LinphoneGlobalOff,
	LinphoneGlobalStartup,
	LinphoneGlobalOn,
	LinphoneGlobalShutdown
}LinphoneGlobalState;

769
const char *linphone_global_state_to_string(LinphoneGlobalState gs);
aymeric's avatar
aymeric committed
770

771 772 773 774 775

/**Call state notification callback prototype*/
typedef void (*LinphoneGlobalStateCb)(struct _LinphoneCore *lc, LinphoneGlobalState gstate, const char *message);
/**Call state notification callback prototype*/
typedef void (*LinphoneCallStateCb)(struct _LinphoneCore *lc, LinphoneCall *call, LinphoneCallState cstate, const char *message);
776 777 778
/**Call encryption changed callback prototype*/
typedef void (*CallEncryptionChangedCb)(struct _LinphoneCore *lc, LinphoneCall *call, bool_t on, const char *authentication_token);

jehan's avatar
jehan committed
779 780 781
/** @ingroup Proxies
 * Registration state notification callback prototype
 * */
jehan's avatar
jehan committed
782
typedef void (*LinphoneRegistrationStateCb)(struct _LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message);
smorlat's avatar
smorlat committed
783
/** Callback prototype */
aymeric's avatar
aymeric committed
784
typedef void (*ShowInterfaceCb)(struct _LinphoneCore *lc);
smorlat's avatar
smorlat committed
785
/** Callback prototype */
aymeric's avatar
aymeric committed
786
typedef void (*DisplayStatusCb)(struct _LinphoneCore *lc, const char *message);
smorlat's avatar
smorlat committed
787
/** Callback prototype */
aymeric's avatar
aymeric committed
788
typedef void (*DisplayMessageCb)(struct _LinphoneCore *lc, const char *message);
smorlat's avatar
smorlat committed
789
/** Callback prototype */
aymeric's avatar
aymeric committed
790
typedef void (*DisplayUrlCb)(struct _LinphoneCore *lc, const char *message, const char *url);
smorlat's avatar
smorlat committed
791
/** Callback prototype */
aymeric's avatar
aymeric committed
792
typedef void (*LinphoneCoreCbFunc)(struct _LinphoneCore *lc,void * user_data);
smorlat's avatar
smorlat committed
793
/** Callback prototype */
794
typedef void (*NotifyReceivedCb)(struct _LinphoneCore *lc, LinphoneCall *call, const char *from, const char *event);
jehan's avatar
jehan committed
795 796 797
/**
 * Report status change for a friend previously \link linphone_core_add_friend() added \endlink to #LinphoneCore.
 * @param lc #LinphoneCore object .
jehan's avatar
jehan committed
798 799 800 801 802 803 804 805 806 807 808 809
 * @param lf Updated #LinphoneFriend .
 */
typedef void (*NotifyPresenceReceivedCb)(struct _LinphoneCore *lc, LinphoneFriend * lf);
/**
 *  Reports that a new subscription request has been received and wait for a decision.
 *  <br> 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 (*NewSubscribtionRequestCb)(struct _LinphoneCore *lc, LinphoneFriend *lf, const char *url);
smorlat's avatar
smorlat committed
810
/** Callback prototype */
aymeric's avatar
aymeric committed
811
typedef void (*AuthInfoRequested)(struct _LinphoneCore *lc, const char *realm, const char *username);
smorlat's avatar
smorlat committed
812
/** Callback prototype */
aymeric's avatar
aymeric committed
813
typedef void (*CallLogUpdated)(struct _LinphoneCore *lc, struct _LinphoneCallLog *newcl);
jehan's avatar
jehan committed
814 815
/**
 * Callback prototype
816
 * @deprecated use #MessageReceived instead.
jehan's avatar
jehan committed
817 818 819 820 821 822 823
 *
 * @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 (*TextMessageReceived)(LinphoneCore *lc, LinphoneChatRoom *room, const LinphoneAddress *from, const char *message);
824 825 826 827 828 829 830 831 832
/**
 * 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 (*MessageReceived)(LinphoneCore *lc, LinphoneChatRoom *room, LinphoneChatMessage *message);
	
smorlat's avatar
smorlat committed
833
/** Callback prototype */
834
typedef void (*DtmfReceived)(struct _LinphoneCore* lc, LinphoneCall *call, int dtmf);
smorlat's avatar
smorlat committed
835
/** Callback prototype */
836
typedef void (*ReferReceived)(struct _LinphoneCore *lc, const char *refer_to);
smorlat's avatar
smorlat committed
837
/** Callback prototype */
838
typedef void (*BuddyInfoUpdated)(struct _LinphoneCore *lc, LinphoneFriend *lf);
839 840
/** Callback prototype for in progress transfers. The new_call_state is the state of the call resulting of the transfer, at the other party. */
typedef void (*LinphoneTransferStateChanged)(struct _LinphoneCore *lc, LinphoneCall *transfered, LinphoneCallState new_call_state);
Simon Morlat's avatar
Simon Morlat committed
841
/** Callback prototype for receiving quality statistics for calls*/
842
typedef void (*CallStatsUpdated)(struct _LinphoneCore *lc, LinphoneCall *call, const LinphoneCallStats *stats);
843

smorlat's avatar
smorlat committed
844 845
/**
 * This structure holds all callbacks that the application should implement.
846
 *  None is mandatory.
smorlat's avatar
smorlat committed
847
**/
848 849 850 851
typedef struct _LinphoneVTable{
	LinphoneGlobalStateCb global_state_changed; /**<Notifies globlal state changes*/
	LinphoneRegistrationStateCb registration_state_changed;/**<Notifies registration state changes*/
	LinphoneCallStateCb call_state_changed;/**<Notifies call state changes*/
852
	NotifyPresenceReceivedCb notify_presence_recv; /**< Notify received presence events*/
jehan's avatar
jehan committed
853
	NewSubscribtionRequestCb new_subscription_request; /**< Notify about pending subscription request */
smorlat's avatar
smorlat committed
854 855
	AuthInfoRequested auth_info_requested; /**< Ask the application some authentication information */
	CallLogUpdated call_log_updated; /**< Notifies that call log list has been updated */
856 857
	TextMessageReceived text_received; /** @deprecated, use #message_received instead <br> A text message has been received */
	MessageReceived message_received; /** a message is received, can be text or external body*/
smorlat's avatar
smorlat committed
858
	DtmfReceived dtmf_received; /**< A dtmf has been received received */
Simon Morlat's avatar
Simon Morlat committed
859
	ReferReceived refer_received; /**< An out of call refer was received */
860
	CallEncryptionChangedCb call_encryption_changed; /**<Notifies on change in the encryption of call streams */
Yann Diorcet's avatar
Yann Diorcet committed
861
	LinphoneTransferStateChanged transfer_state_changed; /**<Notifies when a transfer is in progress */
smorlat's avatar
smorlat committed
862
	BuddyInfoUpdated buddy_info_updated; /**< a LinphoneFriend's BuddyInfo has changed*/
863
	NotifyReceivedCb notify_recv; /**< Other notifications*/
Simon Morlat's avatar
Simon Morlat committed
864
	CallStatsUpdated call_stats_updated; /**<Notifies on refreshing of call's statistics. */
Simon Morlat's avatar
Simon Morlat committed
865 866 867 868 869
	DisplayStatusCb display_status; /**< DEPRECATED Callback that notifies various events with human readable text.*/
	DisplayMessageCb display_message;/**< DEPRECATED Callback to display a message to the user */
	DisplayMessageCb display_warning;/**< DEPRECATED Callback to display a warning to the user */
	DisplayUrlCb display_url; /**< DEPRECATED */
	ShowInterfaceCb show; /**< DEPRECATED Notifies the application that it should show up*/
aymeric's avatar
aymeric committed
870 871
} LinphoneCoreVTable;

smorlat's avatar
smorlat committed
872 873 874 875
/**
 * @}
**/

aymeric's avatar
aymeric committed
876 877 878 879 880 881 882 883 884
typedef struct _LCCallbackObj
{
  LinphoneCoreCbFunc _func;
  void * _user_data;
}LCCallbackObj;



typedef enum _LinphoneFirewallPolicy{
885 886
	LinphonePolicyNoFirewall,
	LinphonePolicyUseNatAddress,
887 888
	LinphonePolicyUseStun,
	LinphonePolicyUseIce
aymeric's avatar
aymeric committed
889 890
} LinphoneFirewallPolicy;

smorlat's avatar
smorlat committed
891 892 893 894 895 896
typedef enum _LinphoneWaitingState{
	LinphoneWaitingStart,
	LinphoneWaitingProgress,
	LinphoneWaitingFinished
} LinphoneWaitingState;
typedef void * (*LinphoneWaitingCallback)(struct _LinphoneCore *lc, void *context, LinphoneWaitingState ws, const char *purpose, float progress);
jehan's avatar
jehan committed
897

aymeric's avatar
aymeric committed
898 899 900 901 902 903 904

/* THE main API */

void linphone_core_enable_logs(FILE *file);
void linphone_core_enable_logs_with_cb(OrtpLogFunc logfunc);
void linphone_core_disable_logs(void);
const char *linphone_core_get_version(void);
905 906
const char *linphone_core_get_user_agent_name(void);
const char *linphone_core_get_user_agent_version(void);
aymeric's avatar
aymeric committed
907 908

LinphoneCore *linphone_core_new(const LinphoneCoreVTable *vtable,
909
						const char *config_path, const char *factory_config, void* userdata);
aymeric's avatar
aymeric committed
910 911

/* function to be periodically called in a main loop */
912
/* For ICE to work properly it should be called every 20ms */
aymeric's avatar
aymeric committed
913
void linphone_core_iterate(LinphoneCore *lc);
jehan's avatar
jehan committed
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
#if 0 /*not implemented yet*/
/**
 * @ingroup initializing
 * Provide Linphone Core with an unique identifier. This be later used to identified contact address coming from this device.
 * Value is not saved.
 * @param lc object
 * @param string identifying the device, can be EMEI or UDID
 *
 */
void linphone_core_set_device_identifier(LinphoneCore *lc,const char* device_id);
/**
 * @ingroup initializing
 * get Linphone unique identifier
 *
 */
const char*  linphone_core_get_device_identifier(const LinphoneCore *lc);

#endif
aymeric's avatar
aymeric committed
932

933 934 935
/*sets the user-agent string in sip messages, ideally called just after linphone_core_new() or linphone_core_init() */
void linphone_core_set_user_agent(LinphoneCore *lc, const char *ua_name, const char *version);

936 937
LinphoneAddress * linphone_core_interpret_url(LinphoneCore *lc, const char *url);

938
LinphoneCall * linphone_core_invite(LinphoneCore *lc, const char *url);
aymeric's avatar
aymeric committed
939

940
LinphoneCall * linphone_core_invite_address(LinphoneCore *lc, const LinphoneAddress *addr);
941

942 943 944 945
LinphoneCall * linphone_core_invite_with_params(LinphoneCore *lc, const char *url, const LinphoneCallParams *params);

LinphoneCall * linphone_core_invite_address_with_params(LinphoneCore *lc, const LinphoneAddress *addr, const LinphoneCallParams *params);

946
int linphone_core_transfer_call(LinphoneCore *lc, LinphoneCall *call, const char *refer_to);
aymeric's avatar
aymeric committed
947

948 949
int linphone_core_transfer_call_to_another(LinphoneCore *lc, LinphoneCall *call, LinphoneCall *dest);

aymeric's avatar
aymeric committed
950 951 952 953
bool_t linphone_core_inc_invite_pending(LinphoneCore*lc);

bool_t linphone_core_in_call(const LinphoneCore *lc);

954
LinphoneCall *linphone_core_get_current_call(const LinphoneCore *lc);
955

956 957
int linphone_core_accept_call(LinphoneCore *lc, LinphoneCall *call);

958 959
int linphone_core_accept_call_with_params(LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params);

960
int linphone_core_terminate_call(LinphoneCore *lc, LinphoneCall *call);
961

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

964 965
int linphone_core_decline_call(LinphoneCore *lc, LinphoneCall * call, LinphoneReason reason);

966
int linphone_core_terminate_all_calls(LinphoneCore *lc);
aymeric's avatar
aymeric committed
967

968 969
int linphone_core_pause_call(LinphoneCore *lc, LinphoneCall *call);

Simon Morlat's avatar
Simon Morlat committed
970 971
int linphone_core_pause_all_calls(LinphoneCore *lc);

972
int linphone_core_resume_call(LinphoneCore *lc, LinphoneCall *call);
aymeric's avatar
aymeric committed
973

974
int linphone_core_update_call(LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params);
975 976 977 978

int linphone_core_defer_call_update(LinphoneCore *lc, LinphoneCall *call);

int linphone_core_accept_call_update(LinphoneCore *lc, LinphoneCall *call, const LinphoneCallParams *params);
979 980 981

LinphoneCallParams *linphone_core_create_default_call_parameters(LinphoneCore *lc);

982
LinphoneCall *linphone_core_get_call_by_remote_address(LinphoneCore *lc, const char *