1 /* 2 types.h 3 Copyright (C) 2010-2017 Belledonne Communications SARL 4 5 This program is free software; you can redistribute it and/or 6 modify it under the terms of the GNU General Public License 7 as published by the Free Software Foundation; either version 2 8 of the License, or (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 18 */ 19 20 #ifndef LINPHONE_TYPES_H_ 21 #define LINPHONE_TYPES_H_ 22 23 24 #include "ortp/payloadtype.h" 25 #include "mediastreamer2/msinterfaces.h" 26 #include "mediastreamer2/msvideo.h" 27 #include "linphone/defs.h" 28 29 30 /** 31 * The LinphoneAccountCreator object used to configure an account on a server via XML-RPC. 32 * @ingroup account_creator 33 **/ 34 typedef struct _LinphoneAccountCreator LinphoneAccountCreator; 35 36 /** 37 * An object to define a LinphoneAccountCreator service. 38 * @ingroup account_creator 39 * @donotwrap 40 **/ 41 typedef struct _LinphoneAccountCreatorService LinphoneAccountCreatorService; 42 43 /** 44 * An object to handle the responses callbacks for handling the LinphoneAccountCreator operations. 45 * @ingroup account_creator 46 **/ 47 typedef struct _LinphoneAccountCreatorCbs LinphoneAccountCreatorCbs; 48 49 /** 50 * Enum describing Phone number checking. 51 * @ingroup account_creator 52 **/ 53 typedef enum _LinphoneAccountCreatorPhoneNumberStatus { 54 LinphoneAccountCreatorPhoneNumberStatusOk = 0x1, /**< Phone number ok */ 55 LinphoneAccountCreatorPhoneNumberStatusTooShort = 0x2, /**< Phone number too short */ 56 LinphoneAccountCreatorPhoneNumberStatusTooLong = 0x4, /**< Phone number too long */ 57 LinphoneAccountCreatorPhoneNumberStatusInvalidCountryCode = 0x8, /**< Country code invalid */ 58 LinphoneAccountCreatorPhoneNumberStatusInvalid = 0x10 /**< Phone number invalid */ 59 } LinphoneAccountCreatorPhoneNumberStatus; 60 61 /** 62 * A mask of #LinphoneAccountCreatorPhoneNumberStatus values 63 * @ingroup account_creator 64 */ 65 typedef unsigned int LinphoneAccountCreatorPhoneNumberStatusMask; 66 67 /** 68 * Enum describing Username checking. 69 * @ingroup account_creator 70 **/ 71 typedef enum _LinphoneAccountCreatorUsernameStatus { 72 LinphoneAccountCreatorUsernameStatusOk, /**< Username ok */ 73 LinphoneAccountCreatorUsernameStatusTooShort, /**< Username too short */ 74 LinphoneAccountCreatorUsernameStatusTooLong, /**< Username too long */ 75 LinphoneAccountCreatorUsernameStatusInvalidCharacters, /**< Contain invalid characters */ 76 LinphoneAccountCreatorUsernameStatusInvalid /**< Invalid username */ 77 } LinphoneAccountCreatorUsernameStatus; 78 79 /** 80 * Enum describing Email checking. 81 * @ingroup account_creator 82 **/ 83 typedef enum _LinphoneAccountCreatorEmailStatus { 84 LinphoneAccountCreatorEmailStatusOk, /**< Email ok */ 85 LinphoneAccountCreatorEmailStatusMalformed, /**< Email malformed */ 86 LinphoneAccountCreatorEmailStatusInvalidCharacters /**< Contain invalid characters */ 87 } LinphoneAccountCreatorEmailStatus; 88 89 /** 90 * Enum describing Password checking. 91 * @ingroup account_creator 92 **/ 93 typedef enum _LinphoneAccountCreatorPasswordStatus { 94 LinphoneAccountCreatorPasswordStatusOk, /**< Password ok */ 95 LinphoneAccountCreatorPasswordStatusTooShort, /**< Password too short */ 96 LinphoneAccountCreatorPasswordStatusTooLong, /**< Password too long */ 97 LinphoneAccountCreatorPasswordStatusInvalidCharacters, /**< Contain invalid characters */ 98 LinphoneAccountCreatorPasswordStatusMissingCharacters /**< Missing specific characters */ 99 } LinphoneAccountCreatorPasswordStatus; 100 101 /** 102 * Enum describing language checking. 103 * @ingroup account_creator 104 **/ 105 typedef enum _LinphoneAccountCreatorLanguageStatus { 106 LinphoneAccountCreatorLanguageStatusOk /**< Language ok */ 107 } LinphoneAccountCreatorLanguageStatus; 108 109 /** 110 * Enum describing Activation code checking. 111 * @ingroup account_creator 112 **/ 113 typedef enum _LinphoneAccountCreatorActivationCodeStatus { 114 LinphoneAccountCreatorActivationCodeStatusOk, /**< Activation code ok */ 115 LinphoneAccountCreatorActivationCodeStatusTooShort, /**< Activation code too short */ 116 LinphoneAccountCreatorActivationCodeStatusTooLong, /**< Activation code too long */ 117 LinphoneAccountCreatorActivationCodeStatusInvalidCharacters /**< Contain invalid characters */ 118 } LinphoneAccountCreatorActivationCodeStatus; 119 120 /** 121 * Enum describing Domain checking 122 * @ingroup account_creator 123 **/ 124 typedef enum _LinphoneAccountCreatorDomainStatus { 125 LinphoneAccountCreatorDomainOk, /**< Domain ok */ 126 LinphoneAccountCreatorDomainInvalid /**< Domain invalid */ 127 } LinphoneAccountCreatorDomainStatus; 128 129 /** 130 * Enum describing Transport checking 131 * @ingroup account_creator 132 **/ 133 typedef enum _LinphoneAccountCreatorTransportStatus { 134 LinphoneAccountCreatorTransportOk, /**< Transport ok */ 135 LinphoneAccountCreatorTransportUnsupported /**< Transport invalid */ 136 } LinphoneAccountCreatorTransportStatus; 137 138 /** 139 * Enum describing the status of server request. 140 * @ingroup account_creator_request 141 **/ 142 typedef enum _LinphoneAccountCreatorStatus { 143 /** Request status **/ 144 LinphoneAccountCreatorStatusRequestOk, /**< Request passed */ 145 LinphoneAccountCreatorStatusRequestFailed, /**< Request failed */ 146 LinphoneAccountCreatorStatusMissingArguments, /**< Request failed due to missing argument(s) */ 147 LinphoneAccountCreatorStatusMissingCallbacks, /**< Request failed due to missing callback(s) */ 148 149 /** Account status **/ 150 /* Creation */ 151 LinphoneAccountCreatorStatusAccountCreated, /**< Account created */ 152 LinphoneAccountCreatorStatusAccountNotCreated, /**< Account not created */ 153 /* Existence */ 154 LinphoneAccountCreatorStatusAccountExist, /**< Account exist */ 155 LinphoneAccountCreatorStatusAccountExistWithAlias, /**< Account exist with alias */ 156 LinphoneAccountCreatorStatusAccountNotExist, /**< Account not exist */ 157 LinphoneAccountCreatorStatusAliasIsAccount, /**< Account was created with Alias */ 158 LinphoneAccountCreatorStatusAliasExist, /**< Alias exist */ 159 LinphoneAccountCreatorStatusAliasNotExist, /**< Alias not exist */ 160 /* Activation */ 161 LinphoneAccountCreatorStatusAccountActivated, /**< Account activated */ 162 LinphoneAccountCreatorStatusAccountAlreadyActivated, /**< Account already activated */ 163 LinphoneAccountCreatorStatusAccountNotActivated, /**< Account not activated */ 164 /* Linking */ 165 LinphoneAccountCreatorStatusAccountLinked, /**< Account linked */ 166 LinphoneAccountCreatorStatusAccountNotLinked, /**< Account not linked */ 167 168 /** Server **/ 169 LinphoneAccountCreatorStatusServerError /**< Error server */ 170 } LinphoneAccountCreatorStatus; 171 172 struct SalAddress; 173 174 /** 175 * Object that represents a SIP address. 176 * 177 * The LinphoneAddress is an opaque object to represents SIP addresses, ie 178 * the content of SIP's 'from' and 'to' headers. 179 * A SIP address is made of display name, username, domain name, port, and various 180 * uri headers (such as tags). It looks like 'Alice <sip:alice@example.net>'. 181 * The LinphoneAddress has methods to extract and manipulate all parts of the address. 182 * When some part of the address (for example the username) is empty, the accessor methods 183 * return NULL. 184 * @ingroup linphone_address 185 */ 186 typedef struct SalAddress LinphoneAddress; 187 188 /** 189 * Enum describing Ip family. 190 * @ingroup initializing 191 **/ 192 typedef enum _LinphoneAddressFamily { 193 LinphoneAddressFamilyInet, /**< IpV4 */ 194 LinphoneAddressFamilyInet6, /**< IpV6 */ 195 LinphoneAddressFamilyUnspec, /**< Unknown */ 196 } LinphoneAddressFamily; 197 198 /** 199 * Enum describing type of audio route. 200 * @ingroup call_control 201 **/ 202 typedef enum _LinphoneAudioRoute { 203 LinphoneAudioRouteEarpiece, 204 LinphoneAudioRouteSpeaker 205 } LinphoneAudioRoute; 206 207 /** 208 * Object holding authentication information. 209 * 210 * @note The object's fields should not be accessed directly. Prefer using 211 * the accessor methods. 212 * 213 * In most case, authentication information consists of a username and password. 214 * Sometimes, a userid is required by proxy, and realm can be useful to discriminate 215 * different SIP domains. 216 * 217 * Once created and filled, a LinphoneAuthInfo must be added to the LinphoneCore in 218 * order to become known and used automatically when needed. 219 * Use linphone_core_add_auth_info() for that purpose. 220 * 221 * The LinphoneCore object can take the initiative to request authentication information 222 * when needed to the application through the auth_info_requested callback of the 223 * LinphoneCoreVTable structure. 224 * 225 * The application can respond to this information request later using 226 * linphone_core_add_auth_info(). This will unblock all pending authentication 227 * transactions and retry them with authentication headers. 228 * 229 * @ingroup authentication 230 **/ 231 typedef struct _LinphoneAuthInfo LinphoneAuthInfo; 232 233 /** 234 * Enum describing the authentication methods 235 * @ingroup network_parameters 236 **/ 237 typedef enum _LinphoneAuthMethod { 238 LinphoneAuthHttpDigest, /**< Digest authentication requested */ 239 LinphoneAuthTls, /**< Client certificate requested */ 240 } LinphoneAuthMethod; 241 242 /** 243 * Enum describing RTP AVPF activation modes. 244 * @ingroup media_parameters 245 **/ 246 typedef enum _LinphoneAVPFMode { 247 LinphoneAVPFDefault = -1, /**< Use default value defined at upper level */ 248 LinphoneAVPFDisabled, /**< AVPF is disabled */ 249 LinphoneAVPFEnabled /**< AVPF is enabled */ 250 } LinphoneAVPFMode; 251 252 /** 253 * The LinphoneContent object representing a data buffer. 254 * @ingroup misc 255 **/ 256 typedef struct _LinphoneBuffer LinphoneBuffer; 257 258 /** 259 * The LinphoneCall object represents a call issued or received by the LinphoneCore 260 * @ingroup call_control 261 **/ 262 typedef struct _LinphoneCall LinphoneCall; 263 264 /** 265 * That class holds all the callbacks which are called by LinphoneCall objects. 266 * 267 * Use linphone_factory_create_call_cbs() to create an instance. Then, call the 268 * callback setters on the events you need to monitor and pass the object to 269 * a LinphoneCall instance through linphone_call_add_callbacks(). 270 * @ingroup call_control 271 */ 272 typedef struct _LinphoneCallCbs LinphoneCallCbs; 273 274 /** 275 * Enum representing the direction of a call. 276 * @ingroup call_logs 277 **/ 278 typedef enum _LinphoneCallDir { 279 LinphoneCallOutgoing, /**< outgoing calls*/ 280 LinphoneCallIncoming /**< incoming calls*/ 281 } LinphoneCallDir; 282 283 /** 284 * Structure representing a call log. 285 * @ingroup call_logs 286 **/ 287 typedef struct _LinphoneCallLog LinphoneCallLog; 288 289 /** 290 * The LinphoneCallParams is an object containing various call related parameters. 291 * It can be used to retrieve parameters from a currently running call or modify 292 * the call's characteristics dynamically. 293 * @ingroup call_control 294 **/ 295 typedef struct _LinphoneCallParams LinphoneCallParams; 296 297 /** 298 * LinphoneCallState enum represents the different state a call can reach into. 299 * The application is notified of state changes through the LinphoneCoreVTable::call_state_changed callback. 300 * @ingroup call_control 301 **/ 302 typedef enum _LinphoneCallState{ 303 LinphoneCallIdle, /**< Initial call state */ 304 LinphoneCallIncomingReceived, /**< This is a new incoming call */ 305 LinphoneCallOutgoingInit, /**< An outgoing call is started */ 306 LinphoneCallOutgoingProgress, /**< An outgoing call is in progress */ 307 LinphoneCallOutgoingRinging, /**< An outgoing call is ringing at remote end */ 308 LinphoneCallOutgoingEarlyMedia, /**< An outgoing call is proposed early media */ 309 LinphoneCallConnected, /**< Connected, the call is answered */ 310 LinphoneCallStreamsRunning, /**< The media streams are established and running */ 311 LinphoneCallPausing, /**< The call is pausing at the initiative of local end */ 312 LinphoneCallPaused, /**< The call is paused, remote end has accepted the pause */ 313 LinphoneCallResuming, /**< The call is being resumed by local end */ 314 LinphoneCallRefered, /**< The call is being transfered to another party, resulting in a new outgoing call to follow immediately */ 315 LinphoneCallError, /**< The call encountered an error */ 316 LinphoneCallEnd, /**< The call ended normally */ 317 LinphoneCallPausedByRemote, /**< The call is paused by remote end */ 318 LinphoneCallUpdatedByRemote, /**< The call's parameters change is requested by remote end, used for example when video is added by remote */ 319 LinphoneCallIncomingEarlyMedia, /**< We are proposing early media to an incoming call */ 320 LinphoneCallUpdating, /**< A call update has been initiated by us */ 321 LinphoneCallReleased, /**< The call object is no more retained by the core */ 322 LinphoneCallEarlyUpdatedByRemote, /**< The call is updated by remote while not yet answered (early dialog SIP UPDATE received) */ 323 LinphoneCallEarlyUpdating /**< We are updating the call while not yet answered (early dialog SIP UPDATE sent) */ 324 } LinphoneCallState; 325 326 /** 327 * The LinphoneCallStats objects carries various statistic informations regarding quality of audio or video streams. 328 * 329 * To receive these informations periodically and as soon as they are computed, the application is invited to place a #LinphoneCoreCallStatsUpdatedCb callback in the LinphoneCoreVTable structure 330 * it passes for instanciating the LinphoneCore object (see linphone_core_new() ). 331 * 332 * At any time, the application can access last computed statistics using linphone_call_get_audio_stats() or linphone_call_get_video_stats(). 333 * @ingroup call_misc 334 **/ 335 typedef struct _LinphoneCallStats LinphoneCallStats; 336 337 /** 338 * Enum representing the status of a call 339 * @ingroup call_logs 340 **/ 341 typedef enum _LinphoneCallStatus { 342 LinphoneCallSuccess, /**< The call was sucessful */ 343 LinphoneCallAborted, /**< The call was aborted */ 344 LinphoneCallMissed, /**< The call was missed (unanswered) */ 345 LinphoneCallDeclined, /**< The call was declined, either locally or by remote end */ 346 LinphoneCallEarlyAborted /**<The call was aborted before being advertised to the application - for protocol reasons*/ 347 } LinphoneCallStatus; 348 349 /** 350 * A chat room message to hold content to be sent. 351 * Can be created by linphone_chat_room_create_message(). 352 * @ingroup chatroom 353 */ 354 typedef struct _LinphoneChatMessage LinphoneChatMessage; 355 356 /** 357 * An object to handle the callbacks for the handling a LinphoneChatMessage objects. 358 * @ingroup chatroom 359 */ 360 typedef struct _LinphoneChatMessageCbs LinphoneChatMessageCbs; 361 362 /** 363 * LinphoneChatMessageState is used to notify if messages have been succesfully delivered or not. 364 * @ingroup chatroom 365 */ 366 typedef enum _LinphoneChatMessageState { 367 LinphoneChatMessageStateIdle, /**< Initial state */ 368 LinphoneChatMessageStateInProgress, /**< Delivery in progress */ 369 LinphoneChatMessageStateDelivered, /**< Message successfully delivered and acknowledged by server */ 370 LinphoneChatMessageStateNotDelivered, /**< Message was not delivered */ 371 LinphoneChatMessageStateFileTransferError, /**< Message was received(and acknowledged) but cannot get file from server */ 372 LinphoneChatMessageStateFileTransferDone, /**< File transfer has been completed successfully */ 373 LinphoneChatMessageStateDeliveredToUser, /**< Message successfully delivered and acknowledged to destination */ 374 LinphoneChatMessageStateDisplayed /**< Message displayed to the remote user */ 375 } LinphoneChatMessageState; 376 377 /** 378 * A chat room is the place where text messages are exchanged. 379 * Can be created by linphone_core_create_chat_room(). 380 * @ingroup chatroom 381 */ 382 typedef struct _LinphoneChatRoom LinphoneChatRoom; 383 384 /** 385 * LinphoneConference class 386 * The _LinphoneConference struct does not exists, it's the Conference C++ class that is used behind 387 * @ingroup call_control 388 */ 389 typedef struct _LinphoneConference LinphoneConference; 390 391 /** 392 * Parameters for initialization of conferences 393 * The _LinphoneConferenceParams struct does not exists, it's the ConferenceParams C++ class that is used behind 394 * @ingroup call_control 395 */ 396 typedef struct _LinphoneConferenceParams LinphoneConferenceParams; 397 398 /** 399 * The LinphoneConfig object is used to manipulate a configuration file. 400 * 401 * The format of the configuration file is a .ini like format: 402 * - sections are defined in [] 403 * - each section contains a sequence of key=value pairs. 404 * 405 * Example: 406 * @code 407 * [sound] 408 * echocanceler=1 409 * playback_dev=ALSA: Default device 410 * 411 * [video] 412 * enabled=1 413 * @endcode 414 * 415 * @ingroup misc 416 **/ 417 typedef struct _LpConfig LinphoneConfig; 418 419 /** 420 * Define old struct name for backward compatibility 421 */ 422 #define LpConfig LinphoneConfig 423 424 /** 425 * LinphoneGlobalState describes the global state of the LinphoneCore object. 426 * It is notified via the LinphoneCoreVTable::global_state_changed 427 * @ingroup initializing 428 **/ 429 typedef enum _LinphoneConfiguringState { 430 LinphoneConfiguringSuccessful, 431 LinphoneConfiguringFailed, 432 LinphoneConfiguringSkipped 433 } LinphoneConfiguringState; 434 435 /** 436 * Consolidated presence information: 'online' means the user is open for communication, 437 * 'busy' means the user is open for communication but involved in an other activity, 438 * 'do not disturb' means the user is not open for communication, and 'offline' means 439 * that no presence information is available. 440 * @ingroup buddy_list 441 */ 442 typedef enum _LinphoneConsolidatedPresence { 443 LinphoneConsolidatedPresenceOnline, 444 LinphoneConsolidatedPresenceBusy, 445 LinphoneConsolidatedPresenceDoNotDisturb, 446 LinphoneConsolidatedPresenceOffline 447 } LinphoneConsolidatedPresence; 448 449 typedef struct _LinphoneContactProvider LinphoneContactProvider; 450 451 typedef struct _LinphoneContactSearch LinphoneContactSearch; 452 453 typedef unsigned int LinphoneContactSearchID; 454 455 /** 456 * Old name of LinphoneContactSearchID 457 * @deprecated 458 * @donotwrap 459 */ 460 LINPHONE_DEPRECATED typedef LinphoneContactSearchID ContactSearchID; 461 462 /** 463 * The LinphoneContent object holds data that can be embedded in a signaling message. 464 * @ingroup misc 465 **/ 466 typedef struct _LinphoneContent LinphoneContent; 467 468 /** 469 * Linphone core main object created by function linphone_core_new() . 470 * @ingroup initializing 471 */ 472 typedef struct _LinphoneCore LinphoneCore; 473 474 /** 475 * That class holds all the callbacks which are called by #LinphoneCore. 476 * 477 * Use linphone_factory_create_core_cbs() to create an instance. Then, call the 478 * callback setters on the events you need to monitor and pass the object to 479 * a #LinphoneCore instance through linphone_core_add_callbacks(). 480 * 481 * That class is inherited from belle_sip_object_t. 482 * @ingroup initializing 483 */ 484 typedef struct _LinphoneCoreCbs LinphoneCoreCbs; 485 486 typedef struct belle_sip_dict LinphoneDictionary; 487 488 /** 489 * Enum describing the result of the echo canceller calibration process. 490 **/ 491 typedef enum { 492 LinphoneEcCalibratorInProgress, /**< The echo canceller calibration process is on going */ 493 LinphoneEcCalibratorDone, /**< The echo canceller calibration has been performed and produced an echo delay measure */ 494 LinphoneEcCalibratorFailed, /**< The echo canceller calibration process has failed */ 495 LinphoneEcCalibratorDoneNoEcho /**< The echo canceller calibration has been performed and no echo has been detected */ 496 } LinphoneEcCalibratorStatus; 497 498 /** 499 * Object representing full details about a signaling error or status. 500 * All LinphoneErrorInfo object returned by the liblinphone API are readonly and transcients. For safety they must be used immediately 501 * after obtaining them. Any other function call to the liblinphone may change their content or invalidate the pointer. 502 * @ingroup misc 503 **/ 504 typedef struct _LinphoneErrorInfo LinphoneErrorInfo; 505 506 /** 507 * Object representing an event state, which is subcribed or published. 508 * @see linphone_core_publish() 509 * @see linphone_core_subscribe() 510 * @ingroup event_api 511 **/ 512 typedef struct _LinphoneEvent LinphoneEvent; 513 514 /** 515 * #LinphoneFactory is a singleton object devoted to the creation of all the object 516 * of Liblinphone that cannot created by #LinphoneCore or #LinphoneCore itself. 517 * @ingroup initializing 518 */ 519 typedef struct _LinphoneFactory LinphoneFactory; 520 521 /** 522 * Policy to use to pass through firewalls. 523 * @ingroup network_parameters 524 * @deprecated Use #LinphoneNatPolicy instead. 525 * @donotwrap 526 **/ 527 typedef enum _LinphoneFirewallPolicy { 528 LinphonePolicyNoFirewall, /**< Do not use any mechanism to pass through firewalls */ 529 LinphonePolicyUseNatAddress, /**< Use the specified public adress */ 530 LinphonePolicyUseStun, /**< Use a STUN server to get the public address */ 531 LinphonePolicyUseIce, /**< Use the ICE protocol */ 532 LinphonePolicyUseUpnp, /**< Use the uPnP protocol */ 533 } LinphoneFirewallPolicy; 534 535 /** 536 * Represents a buddy, all presence actions like subscription and status change notification are performed on this object 537 * @ingroup buddy_list 538 */ 539 typedef struct _LinphoneFriend LinphoneFriend; 540 541 /** 542 * The LinphoneFriendList object representing a list of friends. 543 * @ingroup buddy_list 544 **/ 545 typedef struct _LinphoneFriendList LinphoneFriendList; 546 547 /** 548 * An object to handle the callbacks for LinphoneFriend synchronization. 549 * @ingroup buddy_list 550 **/ 551 typedef struct _LinphoneFriendListCbs LinphoneFriendListCbs; 552 553 /** 554 * Enum describing the status of a LinphoneFriendList operation. 555 * @ingroup buddy_list 556 **/ 557 typedef enum _LinphoneFriendListStatus { 558 LinphoneFriendListOK, 559 LinphoneFriendListNonExistentFriend, 560 LinphoneFriendListInvalidFriend 561 } LinphoneFriendListStatus; 562 563 /** 564 * Enum describing the status of a CardDAV synchronization 565 * @ingroup buddy_list 566 */ 567 typedef enum _LinphoneFriendListSyncStatus { 568 LinphoneFriendListSyncStarted, 569 LinphoneFriendListSyncSuccessful, 570 LinphoneFriendListSyncFailure 571 } LinphoneFriendListSyncStatus; 572 573 /** 574 * LinphoneGlobalState describes the global state of the LinphoneCore object. 575 * It is notified via the LinphoneCoreVTable::global_state_changed 576 * @ingroup initializing 577 **/ 578 typedef enum _LinphoneGlobalState { 579 LinphoneGlobalOff, 580 LinphoneGlobalStartup, 581 LinphoneGlobalOn, 582 LinphoneGlobalShutdown, 583 LinphoneGlobalConfiguring 584 } LinphoneGlobalState; 585 586 /** 587 * Enum describing ICE states. 588 * @ingroup initializing 589 **/ 590 typedef enum _LinphoneIceState { 591 LinphoneIceStateNotActivated, /**< ICE has not been activated for this call or stream*/ 592 LinphoneIceStateFailed, /**< ICE processing has failed */ 593 LinphoneIceStateInProgress, /**< ICE process is in progress */ 594 LinphoneIceStateHostConnection, /**< ICE has established a direct connection to the remote host */ 595 LinphoneIceStateReflexiveConnection, /**< ICE has established a connection to the remote host through one or several NATs */ 596 LinphoneIceStateRelayConnection /**< ICE has established a connection through a relay */ 597 } LinphoneIceState; 598 599 /** 600 * IM encryption engine. 601 * @ingroup misc 602 */ 603 typedef struct _LinphoneImEncryptionEngine LinphoneImEncryptionEngine; 604 605 /** 606 * An object to handle the callbacks for the handling a LinphoneImEncryptionEngine object. 607 * @ingroup misc 608 */ 609 typedef struct _LinphoneImEncryptionEngineCbs LinphoneImEncryptionEngineCbs; 610 611 /** 612 * Policy to use to send/receive instant messaging composing/delivery/display notifications. 613 * The sending of this information is done as in the RFCs 3994 (is_composing) and 5438 (imdn delivered/displayed). 614 * @ingroup chatroom 615 */ 616 typedef struct _LinphoneImNotifPolicy LinphoneImNotifPolicy; 617 618 /** 619 * The LinphoneInfoMessage is an object representing an informational message sent or received by the core. 620 * @ingroup misc 621 **/ 622 typedef struct _LinphoneInfoMessage LinphoneInfoMessage; 623 624 typedef struct _LinphoneLDAPContactProvider LinphoneLDAPContactProvider; 625 626 typedef struct _LinphoneLDAPContactSearch LinphoneLDAPContactSearch; 627 628 /** 629 * @ingroup network_parameters 630 */ 631 typedef enum _LinphoneLimeState { 632 LinphoneLimeDisabled, /**< Lime is not used at all */ 633 LinphoneLimeMandatory, /**< Lime is always used */ 634 LinphoneLimePreferred, /**< Lime is used only if we already shared a secret with remote */ 635 } LinphoneLimeState; 636 637 /** 638 * @ingroup initializing 639 */ 640 typedef enum _LinphoneLogCollectionState { 641 LinphoneLogCollectionDisabled, 642 LinphoneLogCollectionEnabled, 643 LinphoneLogCollectionEnabledWithoutPreviousLogHandler 644 } LinphoneLogCollectionState; 645 646 /** 647 * LinphoneCoreLogCollectionUploadState is used to notify if log collection upload have been succesfully delivered or not. 648 * @ingroup initializing 649 */ 650 typedef enum _LinphoneCoreLogCollectionUploadState { 651 LinphoneCoreLogCollectionUploadStateInProgress, /**< Delivery in progress */ 652 LinphoneCoreLogCollectionUploadStateDelivered, /**< Log collection upload successfully delivered and acknowledged by remote end point */ 653 LinphoneCoreLogCollectionUploadStateNotDelivered, /**< Log collection upload was not delivered */ 654 } LinphoneCoreLogCollectionUploadState; 655 656 /** 657 * Indicates for a given media the stream direction 658 * @ingroup call_control 659 */ 660 typedef enum _LinphoneMediaDirection { 661 LinphoneMediaDirectionInvalid = -1, 662 LinphoneMediaDirectionInactive, /** No active media not supported yet*/ 663 LinphoneMediaDirectionSendOnly, /** Send only mode*/ 664 LinphoneMediaDirectionRecvOnly, /** recv only mode*/ 665 LinphoneMediaDirectionSendRecv, /** send receive*/ 666 } LinphoneMediaDirection; 667 668 /** 669 * Enum describing type of media encryption types. 670 * @ingroup media_parameters 671 **/ 672 typedef enum _LinphoneMediaEncryption { 673 LinphoneMediaEncryptionNone, /**< No media encryption is used */ 674 LinphoneMediaEncryptionSRTP, /**< Use SRTP media encryption */ 675 LinphoneMediaEncryptionZRTP, /**< Use ZRTP media encryption */ 676 LinphoneMediaEncryptionDTLS /**< Use DTLS media encryption */ 677 } LinphoneMediaEncryption; 678 679 /** 680 * Policy to use to pass through NATs/firewalls. 681 * @ingroup network_parameters 682 */ 683 typedef struct _LinphoneNatPolicy LinphoneNatPolicy; 684 685 /** 686 * Enum describing remote friend status 687 * @deprecated Use #LinphonePresenceModel and #LinphonePresenceActivity instead 688 * @donotwrap 689 */ 690 typedef enum _LinphoneOnlineStatus{ 691 LinphoneStatusOffline, /**< Offline */ 692 LinphoneStatusOnline, /**< Online */ 693 LinphoneStatusBusy, /**< Busy */ 694 LinphoneStatusBeRightBack, /**< Be right back */ 695 LinphoneStatusAway, /**< Away */ 696 LinphoneStatusOnThePhone, /** On the phone */ 697 LinphoneStatusOutToLunch, /**< Out to lunch */ 698 LinphoneStatusDoNotDisturb, /**< Do not disturb */ 699 LinphoneStatusMoved, /**< Moved in this sate, call can be redirected if an alternate contact address has been set using function linphone_core_set_presence_info() */ 700 LinphoneStatusAltService, /**< Using another messaging service */ 701 LinphoneStatusPending, /**< Pending */ 702 LinphoneStatusVacation, /**< Vacation */ 703 704 LinphoneStatusEnd 705 } LinphoneOnlineStatus; 706 707 /** 708 * Player interface. 709 * @ingroup call_control 710 **/ 711 typedef struct _LinphonePlayer LinphonePlayer; 712 713 /** 714 * An object to handle the callbacks for the handling a LinphonePlayer objects. 715 * @ingroup call_control 716 */ 717 typedef struct _LinphonePlayerCbs LinphonePlayerCbs; 718 719 /** 720 * The state of a LinphonePlayer. 721 * @ingroup call_control 722 */ 723 typedef enum LinphonePlayerState { 724 LinphonePlayerClosed, /**< No file is opened for playing. */ 725 LinphonePlayerPaused, /**< The player is paused. */ 726 LinphonePlayerPlaying /**< The player is playing. */ 727 } LinphonePlayerState; 728 729 /** 730 * Presence activity type holding information about a presence activity. 731 * @ingroup buddy_list 732 */ 733 typedef struct _LinphonePresenceActivity LinphonePresenceActivity; 734 735 /** 736 * Activities as defined in section 3.2 of RFC 4480 737 * @ingroup buddy_list 738 */ 739 typedef enum LinphonePresenceActivityType { 740 /** The person has a calendar appointment, without specifying exactly of what type. This activity is 741 * indicated if more detailed information is not available or the person chooses not to reveal more 742 * information. */ 743 LinphonePresenceActivityAppointment, 744 745 /** The person is physically away from all interactive communication devices. */ 746 LinphonePresenceActivityAway, 747 748 /** The person is eating the first meal of the day, usually eaten in the morning. */ 749 LinphonePresenceActivityBreakfast, 750 751 /** The person is busy, without further details. */ 752 LinphonePresenceActivityBusy, 753 754 /** The person is having his or her main meal of the day, eaten in the evening or at midday. */ 755 LinphonePresenceActivityDinner, 756 757 /** This is a scheduled national or local holiday. */ 758 LinphonePresenceActivityHoliday, 759 760 /** The person is riding in a vehicle, such as a car, but not steering. */ 761 LinphonePresenceActivityInTransit, 762 763 /** The person is looking for (paid) work. */ 764 LinphonePresenceActivityLookingForWork, 765 766 /** The person is eating his or her midday meal. */ 767 LinphonePresenceActivityLunch, 768 769 /** The person is scheduled for a meal, without specifying whether it is breakfast, lunch, or dinner, 770 * or some other meal. */ 771 LinphonePresenceActivityMeal, 772 773 /** The person is in an assembly or gathering of people, as for a business, social, or religious purpose. 774 * A meeting is a sub-class of an appointment. */ 775 LinphonePresenceActivityMeeting, 776 777 /** The person is talking on the telephone. */ 778 LinphonePresenceActivityOnThePhone, 779 780 /** The person is engaged in an activity with no defined representation. A string describing the activity 781 * in plain text SHOULD be provided. */ 782 LinphonePresenceActivityOther, 783 784 /** A performance is a sub-class of an appointment and includes musical, theatrical, and cinematic 785 * performances as well as lectures. It is distinguished from a meeting by the fact that the person 786 * may either be lecturing or be in the audience, with a potentially large number of other people, 787 * making interruptions particularly noticeable. */ 788 LinphonePresenceActivityPerformance, 789 790 /** The person will not return for the foreseeable future, e.g., because it is no longer working for 791 * the company. */ 792 LinphonePresenceActivityPermanentAbsence, 793 794 /** The person is occupying himself or herself in amusement, sport, or other recreation. */ 795 LinphonePresenceActivityPlaying, 796 797 /** The person is giving a presentation, lecture, or participating in a formal round-table discussion. */ 798 LinphonePresenceActivityPresentation, 799 800 /** The person is visiting stores in search of goods or services. */ 801 LinphonePresenceActivityShopping, 802 803 /** The person is sleeping.*/ 804 LinphonePresenceActivitySleeping, 805 806 /** The person is observing an event, such as a sports event. */ 807 LinphonePresenceActivitySpectator, 808 809 /** The person is controlling a vehicle, watercraft, or plane. */ 810 LinphonePresenceActivitySteering, 811 812 /** The person is on a business or personal trip, but not necessarily in-transit. */ 813 LinphonePresenceActivityTravel, 814 815 /** The person is watching television. */ 816 LinphonePresenceActivityTV, 817 818 /** The activity of the person is unknown. */ 819 LinphonePresenceActivityUnknown, 820 821 /** A period of time devoted to pleasure, rest, or relaxation. */ 822 LinphonePresenceActivityVacation, 823 824 /** The person is engaged in, typically paid, labor, as part of a profession or job. */ 825 LinphonePresenceActivityWorking, 826 827 /** The person is participating in religious rites. */ 828 LinphonePresenceActivityWorship 829 } LinphonePresenceActivityType; 830 831 /** 832 * Basic status as defined in section 4.1.4 of RFC 3863 833 * @ingroup buddy_list 834 */ 835 typedef enum LinphonePresenceBasicStatus { 836 /** This value means that the associated contact element, if any, is ready to accept communication. */ 837 LinphonePresenceBasicStatusOpen, 838 839 /** This value means that the associated contact element, if any, is unable to accept communication. */ 840 LinphonePresenceBasicStatusClosed 841 } LinphonePresenceBasicStatus; 842 843 /** 844 * Presence model type holding information about the presence of a person. 845 * @ingroup buddy_list 846 */ 847 typedef struct _LinphonePresenceModel LinphonePresenceModel; 848 849 /** 850 * Presence note type holding information about a presence note. 851 * @ingroup buddy_list 852 */ 853 typedef struct _LinphonePresenceNote LinphonePresenceNote; 854 855 /** 856 * Presence person holding information about a presence person. 857 * @ingroup buddy_list 858 */ 859 typedef struct _LinphonePresencePerson LinphonePresencePerson; 860 861 /** 862 * Presence service type holding information about a presence service. 863 * @ingroup buddy_list 864 */ 865 typedef struct _LinphonePresenceService LinphonePresenceService; 866 867 /** 868 * @ingroup call_control 869 * Defines privacy policy to apply as described by rfc3323 870 **/ 871 typedef enum _LinphonePrivacy { 872 /** 873 * Privacy services must not perform any privacy function 874 */ 875 LinphonePrivacyNone = 0x0, 876 /** 877 * Request that privacy services provide a user-level privacy 878 * function. 879 * With this mode, "from" header is hidden, usually replaced by From: "Anonymous" <sip:anonymous@anonymous.invalid> 880 */ 881 LinphonePrivacyUser = 0x1, 882 /** 883 * Request that privacy services modify headers that cannot 884 * be set arbitrarily by the user (Contact/Via). 885 */ 886 LinphonePrivacyHeader = 0x2, 887 /** 888 * Request that privacy services provide privacy for session 889 * media 890 */ 891 LinphonePrivacySession = 0x4, 892 /** 893 * rfc3325 894 * The presence of this privacy type in 895 * a Privacy header field indicates that the user would like the Network 896 * Asserted Identity to be kept private with respect to SIP entities 897 * outside the Trust Domain with which the user authenticated. Note 898 * that a user requesting multiple types of privacy MUST include all of 899 * the requested privacy types in its Privacy header field value 900 * 901 */ 902 LinphonePrivacyId = 0x8, 903 /** 904 * Privacy service must perform the specified services or 905 * fail the request 906 * 907 **/ 908 LinphonePrivacyCritical = 0x10, 909 910 /** 911 * Special keyword to use privacy as defined either globally or by proxy using linphone_proxy_config_set_privacy() 912 */ 913 LinphonePrivacyDefault = 0x8000, 914 } LinphonePrivacy; 915 /* WARNING This enum MUST be kept in sync with the SalPrivacy enum from sal.h */ 916 917 /** 918 * A mask of #LinphonePrivacy values 919 * @ingroup call_control 920 */ 921 typedef unsigned int LinphonePrivacyMask; 922 923 /** 924 * The LinphoneProxyConfig object represents a proxy configuration to be used 925 * by the LinphoneCore object. 926 * Its fields must not be used directly in favour of the accessors methods. 927 * Once created and filled properly the LinphoneProxyConfig can be given to 928 * LinphoneCore with linphone_core_add_proxy_config(). 929 * This will automatically triggers the registration, if enabled. 930 * 931 * The proxy configuration are persistent to restarts because they are saved 932 * in the configuration file. As a consequence, after linphone_core_new() there 933 * might already be a list of configured proxy that can be examined with 934 * linphone_core_get_proxy_config_list(). 935 * 936 * The default proxy (see linphone_core_set_default_proxy() ) is the one of the list 937 * that is used by default for calls. 938 * @ingroup proxies 939 **/ 940 typedef struct _LinphoneProxyConfig LinphoneProxyConfig; 941 942 /** 943 * Enum for publish states. 944 * @ingroup event_api 945 **/ 946 typedef enum _LinphonePublishState{ 947 LinphonePublishNone, /**< Initial state, do not use */ 948 LinphonePublishProgress, /**< An outgoing publish was created and submitted */ 949 LinphonePublishOk, /**< Publish is accepted */ 950 LinphonePublishError, /**< Publish encoutered an error, linphone_event_get_reason() gives reason code */ 951 LinphonePublishExpiring, /**< Publish is about to expire, only sent if [sip]->refresh_generic_publish property is set to 0 */ 952 LinphonePublishCleared /**< Event has been un published */ 953 } LinphonePublishState; 954 955 /** 956 * Enum describing various failure reasons or contextual information for some events. 957 * @see linphone_call_get_reason() 958 * @see linphone_proxy_config_get_error() 959 * @see linphone_error_info_get_reason() 960 * @ingroup misc 961 **/ 962 typedef enum _LinphoneReason{ 963 LinphoneReasonNone, /**< No reason has been set by the core */ 964 LinphoneReasonNoResponse, /**< No response received from remote */ 965 LinphoneReasonForbidden, /**< Authentication failed due to bad credentials or resource forbidden */ 966 LinphoneReasonDeclined, /**< The call has been declined */ 967 LinphoneReasonNotFound, /**< Destination of the call was not found */ 968 LinphoneReasonNotAnswered, /**< The call was not answered in time (request timeout) */ 969 LinphoneReasonBusy, /**< Phone line was busy */ 970 LinphoneReasonUnsupportedContent, /**< Unsupported content */ 971 LinphoneReasonIOError, /**< Transport error: connection failures, disconnections etc... */ 972 LinphoneReasonDoNotDisturb, /**< Do not disturb reason */ 973 LinphoneReasonUnauthorized, /**< Operation is unauthorized because missing credential */ 974 LinphoneReasonNotAcceptable, /**< Operation is rejected due to incompatible or unsupported media parameters */ 975 LinphoneReasonNoMatch, /**< Operation could not be executed by server or remote client because it didn't have any context for it */ 976 LinphoneReasonMovedPermanently, /**< Resource moved permanently */ 977 LinphoneReasonGone, /**< Resource no longer exists */ 978 LinphoneReasonTemporarilyUnavailable, /**< Temporarily unavailable */ 979 LinphoneReasonAddressIncomplete, /**< Address incomplete */ 980 LinphoneReasonNotImplemented, /**< Not implemented */ 981 LinphoneReasonBadGateway, /**< Bad gateway */ 982 LinphoneReasonServerTimeout, /**< Server timeout */ 983 LinphoneReasonUnknown /**< Unknown reason */ 984 } LinphoneReason; 985 986 #define LinphoneReasonBadCredentials LinphoneReasonForbidden 987 988 /*for compatibility*/ 989 #define LinphoneReasonMedia LinphoneReasonUnsupportedContent 990 991 /** 992 * LinphoneRegistrationState describes proxy registration states. 993 * @ingroup proxies 994 **/ 995 typedef enum _LinphoneRegistrationState { 996 LinphoneRegistrationNone, /**< Initial state for registrations */ 997 LinphoneRegistrationProgress, /**< Registration is in progress */ 998 LinphoneRegistrationOk, /**< Registration is successful */ 999 LinphoneRegistrationCleared, /**< Unregistration succeeded */ 1000 LinphoneRegistrationFailed /**< Registration failed */ 1001 } LinphoneRegistrationState; 1002 1003 typedef struct _LinphoneRingtonePlayer LinphoneRingtonePlayer; 1004 1005 /** 1006 * Linphone core SIP transport ports. 1007 * Special values #LC_SIP_TRANSPORT_RANDOM, #LC_SIP_TRANSPORT_RANDOM, #LC_SIP_TRANSPORT_DONTBIND can be used. 1008 * Use with #linphone_core_set_sip_transports 1009 * @deprecated 1010 * @donotwrap 1011 */ 1012 typedef struct _LinphoneSipTransports { 1013 int udp_port; /**< SIP/UDP port */ 1014 int tcp_port; /**< SIP/TCP port */ 1015 int dtls_port; /**< SIP/DTLS port */ 1016 int tls_port; /**< SIP/TLS port */ 1017 } LinphoneSipTransports; 1018 1019 /** 1020 * Linphone core SIP transport ports. 1021 * Special values #LC_SIP_TRANSPORT_RANDOM, #LC_SIP_TRANSPORT_RANDOM, #LC_SIP_TRANSPORT_DONTBIND can be used. 1022 * Use with #linphone_core_set_sip_transports 1023 * @ingroup initializing 1024 */ 1025 typedef struct _LinphoneTransports LinphoneTransports; 1026 1027 /** 1028 * Old name of LinphoneSipTransports 1029 * @deprecated 1030 * @donotwrap 1031 */ 1032 LINPHONE_DEPRECATED typedef struct _LinphoneSipTransports LCSipTransports; 1033 1034 typedef struct _LinphoneSoundDaemon LinphoneSoundDaemon; 1035 1036 /** 1037 * Enum describing the stream types. 1038 * @ingroup initializing 1039 **/ 1040 typedef enum _LinphoneStreamType { 1041 LinphoneStreamTypeAudio, 1042 LinphoneStreamTypeVideo, 1043 LinphoneStreamTypeText, 1044 LinphoneStreamTypeUnknown /* WARNING: Make sure this value remains the last one in the list */ 1045 } LinphoneStreamType; 1046 1047 /** 1048 * Enum controlling behavior for incoming subscription request. 1049 * Use by linphone_friend_set_inc_subscribe_policy() 1050 * @ingroup buddy_list 1051 */ 1052 typedef enum _LinphoneSubscribePolicy { 1053 /** 1054 * Does not automatically accept an incoming subscription request. 1055 * This policy implies that a decision has to be taken for each incoming subscription request notified by callback LinphoneCoreVTable.new_subscription_requested 1056 */ 1057 LinphoneSPWait, 1058 LinphoneSPDeny, /**< Rejects incoming subscription request */ 1059 LinphoneSPAccept /**< Automatically accepts a subscription request */ 1060 } LinphoneSubscribePolicy; 1061 1062 /** 1063 * Enum for subscription direction (incoming or outgoing). 1064 * @ingroup event_api 1065 **/ 1066 typedef enum _LinphoneSubscriptionDir{ 1067 LinphoneSubscriptionIncoming, /**< Incoming subscription. */ 1068 LinphoneSubscriptionOutgoing, /**< Outgoing subscription. */ 1069 LinphoneSubscriptionInvalidDir /**< Invalid subscription direction. */ 1070 } LinphoneSubscriptionDir; 1071 1072 /** 1073 * Enum for subscription states. 1074 * LinphoneSubscriptionTerminated and LinphoneSubscriptionError are final states. 1075 * @ingroup event_api 1076 **/ 1077 typedef enum _LinphoneSubscriptionState{ 1078 LinphoneSubscriptionNone, /**< Initial state, should not be used */ 1079 LinphoneSubscriptionOutgoingProgress, /**< An outgoing subcription was sent */ 1080 LinphoneSubscriptionIncomingReceived, /**< An incoming subcription is received */ 1081 LinphoneSubscriptionPending, /**< Subscription is pending, waiting for user approval */ 1082 LinphoneSubscriptionActive, /**< Subscription is accepted */ 1083 LinphoneSubscriptionTerminated, /**< Subscription is terminated normally */ 1084 LinphoneSubscriptionError, /**< Subscription was terminated by an error, indicated by linphone_event_get_reason() */ 1085 LinphoneSubscriptionExpiring, /**< Subscription is about to expire, only sent if [sip]->refresh_generic_subscribe property is set to 0 */ 1086 } LinphoneSubscriptionState; 1087 1088 /** 1089 * Enum listing frequent telephony tones. 1090 * @ingroup misc 1091 **/ 1092 typedef enum _LinphoneToneID { 1093 LinphoneToneUndefined, /**< Not a tone */ 1094 LinphoneToneBusy, /**< Busy tone */ 1095 LinphoneToneCallWaiting, /** Call waiting tone */ 1096 LinphoneToneCallOnHold, /** Call on hold tone */ 1097 LinphoneToneCallLost /** Tone played when call is abruptly disconnected (media lost)*/ 1098 } LinphoneToneID; 1099 1100 /** 1101 * Enum describing transport type for LinphoneAddress. 1102 * @ingroup linphone_address 1103 **/ 1104 typedef enum _LinphoneTransportType { 1105 LinphoneTransportUdp, 1106 LinphoneTransportTcp, 1107 LinphoneTransportTls, 1108 LinphoneTransportDtls 1109 } LinphoneTransportType; 1110 /* WARNING This enum MUST be kept in sync with the SalTransport enum from sal.h */ 1111 1112 /** 1113 * Linphone tunnel object. 1114 * @ingroup tunnel 1115 */ 1116 typedef struct _LinphoneTunnel LinphoneTunnel; 1117 1118 typedef struct _LinphoneTunnelConfig LinphoneTunnelConfig; 1119 1120 /** 1121 * Enum describing the tunnel modes. 1122 * @ingroup tunnel 1123 **/ 1124 typedef enum _LinphoneTunnelMode { 1125 LinphoneTunnelModeDisable, /**< The tunnel is disabled */ 1126 LinphoneTunnelModeEnable, /**< The tunnel is enabled */ 1127 LinphoneTunnelModeAuto /**< The tunnel is enabled automatically if it is required */ 1128 } LinphoneTunnelMode; 1129 1130 /** 1131 * Enum describing uPnP states. 1132 * @ingroup initializing 1133 **/ 1134 typedef enum _LinphoneUpnpState { 1135 LinphoneUpnpStateIdle, /**< uPnP is not activate */ 1136 LinphoneUpnpStatePending, /**< uPnP process is in progress */ 1137 LinphoneUpnpStateAdding, /**< Internal use: Only used by port binding */ 1138 LinphoneUpnpStateRemoving, /**< Internal use: Only used by port binding */ 1139 LinphoneUpnpStateNotAvailable, /**< uPnP is not available */ 1140 LinphoneUpnpStateOk, /**< uPnP is enabled */ 1141 LinphoneUpnpStateKo, /**< uPnP processing has failed */ 1142 LinphoneUpnpStateBlacklisted, /**< IGD router is blacklisted */ 1143 } LinphoneUpnpState; 1144 1145 /** 1146 * The LinphoneVcard object. 1147 * @ingroup carddav_vcard 1148 */ 1149 typedef struct _LinphoneVcard LinphoneVcard; 1150 1151 /** 1152 * Enum describing the result of a version update check. 1153 * @ingroup misc 1154 */ 1155 typedef enum _LinphoneVersionUpdateCheckResult { 1156 LinphoneVersionUpdateCheckUpToDate, 1157 LinphoneVersionUpdateCheckNewVersionAvailable, 1158 LinphoneVersionUpdateCheckError 1159 } LinphoneVersionUpdateCheckResult; 1160 1161 /** 1162 * The LinphoneVideoDefinition object represents a video definition, eg. its width and its height. 1163 * @ingroup media_parameters 1164 */ 1165 typedef struct _LinphoneVideoDefinition LinphoneVideoDefinition; 1166 1167 /** 1168 * Structure describing policy regarding video streams establishments. 1169 * @ingroup media_parameters 1170 * @deprecated 1171 * @donotwrap 1172 **/ 1173 typedef struct _LinphoneVideoPolicy { 1174 bool_t automatically_initiate; /**<Whether video shall be automatically proposed for outgoing calls.*/ 1175 bool_t automatically_accept; /**<Whether video shall be automatically accepted for incoming calls*/ 1176 bool_t unused[2]; 1177 } LinphoneVideoPolicy; 1178 1179 /** 1180 * Structure describing policy regarding video streams establishments. 1181 * @ingroup media_parameters 1182 **/ 1183 typedef struct _LinphoneVideoActivationPolicy LinphoneVideoActivationPolicy; 1184 1185 typedef struct LinphoneVideoSizeDef { 1186 MSVideoSize vsize; 1187 const char *name; 1188 } LinphoneVideoSizeDef; 1189 1190 /** 1191 * Old name of LinphoneVideoSizeDef 1192 * @deprecated 1193 */ 1194 typedef LinphoneVideoSizeDef MSVideoSizeDef; 1195 1196 typedef enum _LinphoneWaitingState { 1197 LinphoneWaitingStart, 1198 LinphoneWaitingProgress, 1199 LinphoneWaitingFinished 1200 } LinphoneWaitingState; 1201 1202 /** 1203 * Enum describing the types of argument for LinphoneXmlRpcRequest. 1204 * @ingroup misc 1205 **/ 1206 typedef enum _LinphoneXmlRpcArgType { 1207 LinphoneXmlRpcArgNone, 1208 LinphoneXmlRpcArgInt, 1209 LinphoneXmlRpcArgString 1210 } LinphoneXmlRpcArgType; 1211 1212 /** 1213 * The LinphoneXmlRpcRequest object representing a XML-RPC request to be sent. 1214 * @ingroup misc 1215 **/ 1216 typedef struct _LinphoneXmlRpcRequest LinphoneXmlRpcRequest; 1217 1218 /** 1219 * An object to handle the callbacks for handling the LinphoneXmlRpcRequest operations. 1220 * @ingroup misc 1221 **/ 1222 typedef struct _LinphoneXmlRpcRequestCbs LinphoneXmlRpcRequestCbs; 1223 1224 /** 1225 * The LinphoneXmlRpcSession object used to send XML-RPC requests and handle their responses. 1226 * @ingroup misc 1227 **/ 1228 typedef struct _LinphoneXmlRpcSession LinphoneXmlRpcSession; 1229 1230 /** 1231 * Enum describing the status of a LinphoneXmlRpcRequest. 1232 * @ingroup misc 1233 **/ 1234 typedef enum _LinphoneXmlRpcStatus { 1235 LinphoneXmlRpcStatusPending, 1236 LinphoneXmlRpcStatusOk, 1237 LinphoneXmlRpcStatusFailed 1238 } LinphoneXmlRpcStatus; 1239 1240 typedef struct _LsdPlayer LsdPlayer; 1241 1242 /** 1243 * Object representing an RTP payload type. 1244 * @ingroup media_parameters 1245 */ 1246 typedef struct _LinphonePayloadType LinphonePayloadType; 1247 1248 /** 1249 * Structure describing a range of integers 1250 * @ingroup misc 1251 */ 1252 typedef struct _LinphoneRange LinphoneRange; 1253 1254 /** 1255 * Status code returned by some functions to 1256 * notify whether the execution has been succesfully 1257 * done or not. 1258 * @ingroup misc 1259 */ 1260 typedef int LinphoneStatus; 1261 1262 /** 1263 * Object representing a chain of protocol headers. 1264 * It provides read/write access to the headers of the underlying protocol. 1265 * @ingroup misc 1266 **/ 1267 typedef struct _LinphoneHeaders LinphoneHeaders; 1268 1269 #endif /* LINPHONE_TYPES_H_ */ 1270