sjero.net Git - linphone/blob - java/common/org/linphone/core/LinphoneCore.java

   1 /*
   2 LinphoneCore.java
   3 Copyright (C) 2010  Belledonne Communications, Grenoble, France
   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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19 package org.linphone.core;
  20
  21 import java.util.Vector;
  22
  23 /**
  24  * Linphone core main object created by method {@link LinphoneCoreFactory#createLinphoneCore(LinphoneCoreListener, String, String, Object)}.
  25  *
  26  */
  27
  28 public interface LinphoneCore {
  29         /**
  30          * linphone core states
  31          */
  32         static public class GlobalState {
  33
  34                 static private Vector<GlobalState> values = new Vector<GlobalState>();
  35                 /**
  36                  * Off
  37                  */
  38                 static public GlobalState GlobalOff = new GlobalState(0,"GlobalOff");
  39                 /**
  40                  * Startup
  41                  */
  42                 static public GlobalState GlobalStartup = new GlobalState(1,"GlobalStartup");
  43                 /**
  44                  * On
  45                  */
  46                 static public GlobalState GlobalOn = new GlobalState(2,"GlobalOn");
  47                 /**
  48                  * Shutdown
  49                  */
  50                 static public GlobalState GlobalShutdown = new GlobalState(3,"GlobalShutdown");
  51
  52                 private final int mValue;
  53                 private final String mStringValue;
  54
  55
  56                 private GlobalState(int value,String stringValue) {
  57                         mValue = value;
  58                         values.addElement(this);
  59                         mStringValue=stringValue;
  60                 }
  61                 public static GlobalState fromInt(int value) {
  62
  63                         for (int i=0; i<values.size();i++) {
  64                                 GlobalState state = (GlobalState) values.elementAt(i);
  65                                 if (state.mValue == value) return state;
  66                         }
  67                         throw new RuntimeException("state not found ["+value+"]");
  68                 }
  69                 public String toString() {
  70                         return mStringValue;
  71                 }
  72         }
  73         /**
  74          * Describes proxy registration states.
  75          *
  76          */
  77         static public class RegistrationState {
  78
  79                 private static Vector<RegistrationState> values = new Vector<RegistrationState>();
  80                 /**
  81                  * None
  82                  */
  83                 public static RegistrationState RegistrationNone = new RegistrationState(0,"RegistrationNone");
  84                 /**
  85                  * In Progress
  86                  */
  87                 public static RegistrationState RegistrationProgress  = new RegistrationState(1,"RegistrationProgress");
  88                 /**
  89                  * Ok
  90                  */
  91                 public static RegistrationState RegistrationOk = new RegistrationState(2,"RegistrationOk");
  92                 /**
  93                  * Cleared
  94                  */
  95                 public static RegistrationState RegistrationCleared = new RegistrationState(3,"RegistrationCleared");
  96                 /**
  97                  * Failed
  98                  */
  99                 public static RegistrationState RegistrationFailed = new RegistrationState(4,"RegistrationFailed");
 100                 private final int mValue;
 101                 private final String mStringValue;
 102
 103
 104                 private RegistrationState(int value,String stringValue) {
 105                         mValue = value;
 106                         values.addElement(this);
 107                         mStringValue=stringValue;
 108                 }
 109                 public static RegistrationState fromInt(int value) {
 110
 111                         for (int i=0; i<values.size();i++) {
 112                                 RegistrationState state = (RegistrationState) values.elementAt(i);
 113                                 if (state.mValue == value) return state;
 114                         }
 115                         throw new RuntimeException("state not found ["+value+"]");
 116                 }
 117                 public String toString() {
 118                         return mStringValue;
 119                 }
 120         }
 121         /**
 122          * Describes firewall policy.
 123          *
 124          */
 125         static public class FirewallPolicy {
 126
 127                 static private Vector<FirewallPolicy> values = new Vector<FirewallPolicy>();
 128                 /**
 129                  * No firewall is assumed.
 130                  */
 131                 static public FirewallPolicy NoFirewall = new FirewallPolicy(0,"NoFirewall");
 132                 /**
 133                  * Use NAT address (discouraged)
 134                  */
 135                 static public FirewallPolicy UseNatAddress  = new FirewallPolicy(1,"UseNatAddress");
 136                 /**
 137                  * Use stun server to discover RTP addresses and ports.
 138                  */
 139                 static public FirewallPolicy UseStun = new FirewallPolicy(2,"UseStun");
 140                 /**
 141                  * Use ICE.
 142                  */
 143                 static public FirewallPolicy UseIce = new FirewallPolicy(3,"UseIce");
 144
 145                 private final int mValue;
 146                 private final String mStringValue;
 147
 148
 149                 private FirewallPolicy(int value,String stringValue) {
 150                         mValue = value;
 151                         values.addElement(this);
 152                         mStringValue=stringValue;
 153                 }
 154                 public static FirewallPolicy fromInt(int value) {
 155
 156                         for (int i=0; i<values.size();i++) {
 157                                 FirewallPolicy state = (FirewallPolicy) values.elementAt(i);
 158                                 if (state.mValue == value) return state;
 159                         }
 160                         throw new RuntimeException("state not found ["+value+"]");
 161                 }
 162                 public String toString() {
 163                         return mStringValue;
 164                 }
 165                 public int value(){
 166                         return mValue;
 167                 }
 168         }
 169
 170         /**
 171          * Signaling transports ports.
 172          */
 173         static public class Transports {
 174                 public int udp;
 175                 public int tcp;
 176                 public int tls;
 177
 178                 public Transports() {};
 179                 public Transports(Transports t) {
 180                         this.udp = t.udp;
 181                         this.tcp = t.tcp;
 182                         this.tls = t.tls;
 183                 }
 184                 public String toString() {
 185                         return "udp["+udp+"] tcp["+tcp+"] tls["+tls+"]";
 186                 }
 187         }
 188         /**
 189          * Media (RTP) encryption enum-like.
 190          *
 191          */
 192         static public final class MediaEncryption {
 193
 194                 static private Vector<MediaEncryption> values = new Vector<MediaEncryption>();
 195                 /**
 196                  * None
 197                  */
 198                 static public final MediaEncryption None = new MediaEncryption(0,"None");
 199                 /**
 200                  * SRTP
 201                  */
 202                 static public final MediaEncryption SRTP = new MediaEncryption(1,"SRTP");
 203                 /**
 204                  * ZRTP
 205                  */
 206                 static public final MediaEncryption ZRTP = new MediaEncryption(2,"ZRTP");
 207                 protected final int mValue;
 208                 private final String mStringValue;
 209
 210
 211                 private MediaEncryption(int value,String stringValue) {
 212                         mValue = value;
 213                         values.addElement(this);
 214                         mStringValue=stringValue;
 215                 }
 216                 public static MediaEncryption fromInt(int value) {
 217
 218                         for (int i=0; i<values.size();i++) {
 219                                 MediaEncryption menc = (MediaEncryption) values.elementAt(i);
 220                                 if (menc.mValue == value) return menc;
 221                         }
 222                         throw new RuntimeException("MediaEncryption not found ["+value+"]");
 223                 }
 224                 public String toString() {
 225                         return mStringValue;
 226                 }
 227         }
 228         /**
 229          *      EC Calibrator Status
 230          */
 231         static public class EcCalibratorStatus {
 232
 233                 static private Vector<EcCalibratorStatus> values = new Vector<EcCalibratorStatus>();
 234                 /* Do not change the values of these constants or the strings associated with them to prevent breaking
 235                    the collection of echo canceller calibration results during the wizard! */
 236                 public static final int IN_PROGRESS_STATUS=0;
 237                 public static final int DONE_STATUS=1;
 238                 public static final int FAILED_STATUS=2;
 239                 public static final int DONE_NO_ECHO_STATUS=3;
 240                 /**
 241                  * Calibration in progress
 242                  */
 243                 static public EcCalibratorStatus InProgress = new EcCalibratorStatus(IN_PROGRESS_STATUS,"InProgress");
 244                 /**
 245                  * Calibration done that produced an echo delay measure
 246                  */
 247                 static public EcCalibratorStatus Done = new EcCalibratorStatus(DONE_STATUS,"Done");
 248                 /**
 249                  * Calibration failed
 250                  */
 251                 static public EcCalibratorStatus Failed = new EcCalibratorStatus(FAILED_STATUS,"Failed");
 252                 /**
 253                  * Calibration done with no echo detected
 254                  */
 255                 static public EcCalibratorStatus DoneNoEcho = new EcCalibratorStatus(DONE_NO_ECHO_STATUS, "DoneNoEcho");
 256
 257                 private final int mValue;
 258                 private final String mStringValue;
 259
 260
 261                 private EcCalibratorStatus(int value,String stringValue) {
 262                         mValue = value;
 263                         values.addElement(this);
 264                         mStringValue=stringValue;
 265                 }
 266                 public static EcCalibratorStatus fromInt(int value) {
 267
 268                         for (int i=0; i<values.size();i++) {
 269                                 EcCalibratorStatus status = (EcCalibratorStatus) values.elementAt(i);
 270                                 if (status.mValue == value) return status;
 271                         }
 272                         throw new RuntimeException("status not found ["+value+"]");
 273                 }
 274                 public String toString() {
 275                         return mStringValue;
 276                 }
 277                 public int value(){
 278                         return mValue;
 279                 }
 280         }
 281
 282         static public class UpnpState {
 283                 static private Vector<UpnpState> values = new Vector<UpnpState>();
 284                 /**
 285                  * Idle
 286                  */
 287                 static public UpnpState Idle = new UpnpState(0, "Idle");
 288                 /**
 289                  * Pending
 290                  */
 291                 static public UpnpState Pending = new UpnpState(1, "Pending");
 292                 /**
 293                  * Adding
 294                  */
 295                 static public UpnpState Adding = new UpnpState(2, "Adding");
 296                 /**
 297                  * Removing
 298                  */
 299                 static public UpnpState Removing = new UpnpState(3, "Removing");
 300                 /**
 301                  * Not Available
 302                  */
 303                 static public UpnpState NotAvailable = new UpnpState(4, "Not available");
 304                 /**
 305                  * Ok
 306                  */
 307                 static public UpnpState Ok = new UpnpState(5, "Ok");
 308                 /**
 309                  * Ko
 310                  */
 311                 static public UpnpState Ko = new UpnpState(6, "Ko");
 312                 protected final int mValue;
 313                 private final String mStringValue;
 314
 315                 private UpnpState(int value, String stringValue) {
 316                         mValue = value;
 317                         values.addElement(this);
 318                         mStringValue = stringValue;
 319                 }
 320                 public static UpnpState fromInt(int value) {
 321                         for (int i = 0; i < values.size(); i++) {
 322                                 UpnpState mstate = (UpnpState) values.elementAt(i);
 323                                 if (mstate.mValue == value) return mstate;
 324                         }
 325                         throw new RuntimeException("UpnpState not found [" + value + "]");
 326                 }
 327                 public String toString() {
 328                         return mStringValue;
 329                 }
 330         }
 331
 332         /**
 333          * Set the context of creation of the LinphoneCore.
 334          */
 335         public void setContext(Object context);
 336
 337         /**
 338          * clear all added proxy configs
 339          */
 340         public void clearProxyConfigs();
 341         /**
 342          * Add a proxy configuration. This will start registration on the proxy, if registration is enabled.
 343          * @param proxyCfg
 344          * @throws LinphoneCoreException
 345          */
 346         public void addProxyConfig(LinphoneProxyConfig proxyCfg) throws LinphoneCoreException;
 347         /**
 348          * Sets the default proxy.
 349          *<br>
 350          * This default proxy must be part of the list of already entered {@link LinphoneProxyConfig}.
 351          * Toggling it as default will make LinphoneCore use the identity associated with the proxy configuration in all incoming and outgoing calls.
 352          * @param proxyCfg
 353          */
 354         public void setDefaultProxyConfig(LinphoneProxyConfig proxyCfg);
 355
 356         /**
 357          * get he default proxy configuration, that is the one used to determine the current identity.
 358          * @return null if no default proxy config
 359          */
 360         public LinphoneProxyConfig getDefaultProxyConfig() ;
 361
 362         /**
 363          * clear all the added auth info
 364          */
 365         void clearAuthInfos();
 366         /**
 367          * Adds authentication information to the LinphoneCore.
 368          * <br>This information will be used during all SIP transacations that require authentication.
 369          * @param info
 370          */
 371         void addAuthInfo(LinphoneAuthInfo info);
 372
 373         /**
 374          * Build an address according to the current proxy config. In case destination is not a sip address, the default proxy domain is automatically appended
 375          * @param destination
 376          * @return
 377          * @throws If no LinphoneAddress can be built from destination
 378          */
 379         public LinphoneAddress interpretUrl(String destination) throws LinphoneCoreException;
 380
 381         /**
 382          * Starts a call given a destination. Internally calls {@link #interpretUrl(String)} then {@link #invite(LinphoneAddress)}.
 383          * @param uri
 384          */
 385         public LinphoneCall invite(String destination)throws LinphoneCoreException;
 386         /**
 387          * Initiates an outgoing call given a destination LinphoneAddress
 388          *<br>The LinphoneAddress can be constructed directly using linphone_address_new(), or created by linphone_core_interpret_url(). The application doesn't own a reference to the returned LinphoneCall object. Use linphone_call_ref() to safely keep the LinphoneCall pointer valid within your application.
 389          * @param to the destination of the call (sip address).
 390          * @return LinphoneCall
 391          * @throws LinphoneCoreException
 392          */
 393         public LinphoneCall invite(LinphoneAddress to)throws LinphoneCoreException;
 394         /**
 395          * Terminates a call.
 396          * @param aCall to be terminated
 397          */
 398         public void terminateCall(LinphoneCall aCall);
 399         /**
 400          * Returns The LinphoneCall the current call if one is in call
 401          *
 402         **/
 403         public LinphoneCall getCurrentCall();
 404
 405         /**
 406          * get current call remote address in case of in/out call
 407          * @return null if no call engaged yet
 408          */
 409         public LinphoneAddress getRemoteAddress();
 410         /**
 411          *
 412          * @return  TRUE if there is a call running or pending.
 413          */
 414         public boolean isIncall();
 415         /**
 416          *
 417          * @return Returns true if in incoming call is pending, ie waiting for being answered or declined.
 418          */
 419         public boolean isInComingInvitePending();
 420         /**
 421          * Main loop function. It is crucial that your application call it periodically.
 422          *
 423          *      #iterate() performs various backgrounds tasks:
 424          * <li>receiving of SIP messages
 425          * <li> handles timers and timeout
 426          * <li> performs registration to proxies
 427          * <li> authentication retries The application MUST call this function from periodically, in its main loop.
 428          * <br> Be careful that this function must be call from the same thread as other liblinphone methods. In not the case make sure all liblinphone calls are serialized with a mutex.
 429
 430          */
 431         public void iterate();
 432         /**
 433          * Accept an incoming call.
 434          *
 435          * Basically the application is notified of incoming calls within the
 436          * {@link LinphoneCoreListener#callState} listener method.
 437          * The application can later respond positively to the call using
 438          * this method.
 439          * @throws LinphoneCoreException
 440          */
 441         public void acceptCall(LinphoneCall aCall) throws LinphoneCoreException;
 442
 443         /**
 444          * Accept an incoming call.
 445          *
 446          * Basically the application is notified of incoming calls within the
 447          * {@link LinphoneCoreListener#callState} listener method.
 448          * The application can later respond positively to the call using
 449          * this method.
 450          * @throws LinphoneCoreException
 451          */
 452         public void acceptCallWithParams(LinphoneCall aCall, LinphoneCallParams params) throws LinphoneCoreException;
 453
 454         /**
 455          * Accept call modifications initiated by other end.
 456          *
 457          * Basically the application is notified of incoming calls within the
 458          * {@link LinphoneCoreListener#callState} listener method.
 459          * The application can later respond positively to the call using
 460          * this method.
 461          * @throws LinphoneCoreException
 462          */
 463         public void acceptCallUpdate(LinphoneCall aCall, LinphoneCallParams params) throws LinphoneCoreException;
 464
 465
 466         /**
 467          * Prevent LinphoneCore from performing an automatic answer
 468          *
 469          * Basically the application is notified of incoming calls within the
 470          * {@link LinphoneCoreListener#callState} listener method.
 471          * The application can later respond positively to the call using
 472          * this method.
 473          * @throws LinphoneCoreException
 474          */
 475         public void deferCallUpdate(LinphoneCall aCall) throws LinphoneCoreException;
 476
 477         public void startRinging();
 478
 479         /**
 480          * @return a list of LinphoneCallLog
 481          */
 482         public LinphoneCallLog[] getCallLogs();
 483
 484         /**
 485          * This method is called by the application to notify the Linphone core library when network is reachable.
 486          * Calling this method with true trigger Linphone to initiate a registration process for all proxy
 487          * configuration with parameter register set to enable.
 488          * This method disable the automatic registration mode. It means you must call this method after each network state changes
 489          * @param network state
 490          *
 491          */
 492         public void setNetworkReachable(boolean isReachable);
 493         /**
 494          *
 495          * @return if false, there is no network connection.
 496          */
 497         public boolean isNetworkReachable();
 498         /**
 499          * destroy linphone core and free all underlying resources
 500          */
 501         public void destroy();
 502         /**
 503          * Allow to control play level before entering  sound card:
 504          * @param level in db
 505          */
 506         public void setPlaybackGain(float gain);
 507         /**
 508          * get play level before entering  sound card:
 509          * @return level in db
 510          */
 511         public float getPlaybackGain();
 512         /**
 513          * set play level
 514          * @param level [0..100]
 515          */
 516         public void setPlayLevel(int level);
 517         /**
 518          * get playback level [0..100];
 519          * -1 if not cannot be determined
 520          * @return
 521          */
 522         public int getPlayLevel();
 523         /**
 524          *  Mutes or unmutes the local microphone.
 525          * @param isMuted
 526          */
 527         void muteMic(boolean isMuted);
 528         /**
 529          *
 530          * @return true is mic is muted
 531          */
 532         boolean isMicMuted();
 533
 534         /**
 535          * Initiate a dtmf signal if in call
 536          * @param number
 537          */
 538         void sendDtmf(char number);
 539         /**
 540          * Initiate a dtmf signal to the speaker if not in call.
 541          * Sending of the DTMF is done in another function.
 542          * @param number
 543          * @param duration in ms , -1 for unlimited
 544          */
 545         void playDtmf(char number,int duration);
 546         /**
 547          * stop current dtmf
 548          */
 549         void stopDtmf();
 550
 551         /**
 552          * remove all call logs
 553          */
 554         void clearCallLogs();
 555         /***
 556          * get payload type  from mime type, clock rate, and number of channels.-
 557          *
 558          * return null if not found
 559          */
 560         PayloadType findPayloadType(String mime, int clockRate, int channels);
 561         /***
 562          * get payload type  from mime type and clock rate..
 563          *
 564          * return null if not found
 565          */
 566         PayloadType findPayloadType(String mime, int clockRate);
 567         /**
 568          * not implemented yet
 569          * @param pt
 570          * @param enable
 571          * @throws LinphoneCoreException
 572          */
 573         void enablePayloadType(PayloadType pt, boolean enable) throws LinphoneCoreException;
 574         /**
 575          * Enables or disable echo cancellation.
 576          * @param enable
 577          */
 578         void enableEchoCancellation(boolean enable);
 579         /**
 580          * get EC status
 581          * @return true if echo cancellation is enabled.
 582          */
 583         boolean isEchoCancellationEnabled();
 584         /**
 585          * Get echo limiter status (another method of doing echo suppression, more brute force)
 586          * @return true if echo limiter is enabled
 587          */
 588         boolean isEchoLimiterEnabled();
 589         /**
 590          * @param transports used for signaling (TCP, UDP and TLS)
 591          */
 592         void setSignalingTransportPorts(Transports transports);
 593         /**
 594          * @return transports used for signaling (TCP, UDP, TLS)
 595          */
 596         Transports getSignalingTransportPorts();
 597         /**
 598          * Activates or deactivates the speaker.
 599          * @param value
 600          */
 601         void enableSpeaker(boolean value);
 602         /**
 603          * Tells whether the speaker is activated.
 604          * @return true if speaker enabled, false otherwise
 605          */
 606         boolean isSpeakerEnabled();
 607         /**
 608          * add a friend to the current buddy list, if subscription attribute is set, a SIP SUBSCRIBE message is sent.
 609          * @param lf LinphoenFriend to add
 610          * @throws LinphoneCoreException
 611          */
 612         void addFriend(LinphoneFriend lf) throws LinphoneCoreException;
 613
 614         /**
 615          * Set my presence status
 616          * @param minute_away how long in away
 617          * @param status sip uri used to redirect call in state LinphoneStatusMoved
 618          */
 619         void setPresenceInfo(int minute_away,String alternative_contact, OnlineStatus status);
 620         /**
 621          * Create a new chat room for messaging from a sip uri like sip:joe@sip.linphone.org
 622          * @param to    destination address for messages
 623          *
 624          * @return {@link LinphoneChatRoom} where messaging can take place.
 625          */
 626         LinphoneChatRoom createChatRoom(String to);
 627
 628         void setVideoWindow(Object w);
 629         void setPreviewWindow(Object w);
 630         void setDeviceRotation(int rotation);
 631
 632         void setVideoDevice(int id);
 633         int getVideoDevice();
 634
 635         /**
 636          * Enables video globally.
 637          *
 638          *
 639          * This function does not have any effect during calls. It just indicates #LinphoneCore to
 640          * initiate future calls with video or not. The two boolean parameters indicate in which
 641          * direction video is enabled. Setting both to false disables video entirely.
 642          *
 643          * @param vcap_enabled indicates whether video capture is enabled
 644          * @param display_enabled indicates whether video display should be shown
 645          *
 646         **/
 647         void enableVideo(boolean vcap_enabled, boolean display_enabled);
 648         /**
 649          * Returns TRUE if video is enabled, FALSE otherwise.
 650          *
 651          ***/
 652         boolean isVideoEnabled();
 653
 654         /**
 655          * Specify a STUN server to help firewall traversal.
 656          * @param stun_server Stun server address and port, such as stun.linphone.org or stun.linphone.org:3478
 657          */
 658         void setStunServer(String stun_server);
 659         /**
 660          * @return stun server address if previously set.
 661          */
 662         String getStunServer();
 663
 664         /**
 665          * Sets policy regarding workarounding NATs
 666          * @param pol one of the FirewallPolicy members.
 667         **/
 668         void setFirewallPolicy(FirewallPolicy pol);
 669         /**
 670          * @return previously set firewall policy.
 671          */
 672         FirewallPolicy getFirewallPolicy();
 673
 674         LinphoneCall inviteAddressWithParams(LinphoneAddress destination, LinphoneCallParams params) throws LinphoneCoreException ;
 675
 676         int updateCall(LinphoneCall call, LinphoneCallParams params);
 677
 678         LinphoneCallParams createDefaultCallParameters();
 679
 680         /**
 681          * Sets the path to a wav file used for ringing.
 682          *
 683          * @param path The file must be a wav 16bit linear. Local ring is disabled if null
 684          */
 685         void setRing(String path);
 686         /**
 687          * gets the path to a wav file used for ringing.
 688          *
 689          * @param null if not set
 690          */
 691         String getRing();
 692
 693         /**
 694          * Sets file or folder containing trusted root CAs
 695          *
 696          * @param path path to file with multiple PEM certif or to folder with multiple PEM files
 697          */
 698         void setRootCA(String path);
 699
 700         void setUploadBandwidth(int bw);
 701
 702         void setDownloadBandwidth(int bw);
 703
 704         /**
 705          * Sets audio packetization interval suggested for remote end.
 706          * @param ptime packetization interval in milliseconds
 707          */
 708         void setDownloadPtime(int ptime);
 709
 710         /**
 711          * Sets audio packetization interval sent to remote end.
 712          * @param ptime packetization interval in milliseconds
 713          */
 714         void setUploadPtime(int ptime);
 715
 716         void setPreferredVideoSize(VideoSize vSize);
 717
 718         VideoSize getPreferredVideoSize();
 719
 720         /**
 721          * Returns the currently supported audio codecs, as PayloadType elements
 722          * @return
 723          */
 724         PayloadType[] getAudioCodecs();
 725         /**
 726          * Returns the currently supported video codecs, as PayloadType elements
 727          * @return
 728          */
 729         PayloadType[] getVideoCodecs();
 730         /**
 731          * enable signaling keep alive. small udp packet sent periodically to keep udp NAT association
 732          */
 733         void enableKeepAlive(boolean enable);
 734         /**
 735          * get keep elive mode
 736          * @return true if enable
 737          */
 738         boolean isKeepAliveEnabled();
 739         /**
 740          * Start an echo calibration of the sound devices, in order to find adequate settings for the echo canceler automatically.
 741          * status is notified to {@link LinphoneCoreListener#ecCalibrationStatus(EcCalibratorStatus, int, Object)}
 742          * @param User object
 743          * @throws LinphoneCoreException if operation is still in progress;
 744         **/
 745         void startEchoCalibration(Object data) throws LinphoneCoreException;
 746
 747         void enableIpv6(boolean enable);
 748         /**
 749          * @deprecated
 750          * @param i
 751          */
 752         void adjustSoftwareVolume(int i);
 753
 754         boolean pauseCall(LinphoneCall call);
 755         boolean resumeCall(LinphoneCall call);
 756         boolean pauseAllCalls();
 757
 758         void setZrtpSecretsCache(String file);
 759         void enableEchoLimiter(boolean val);
 760
 761         boolean isInConference();
 762         boolean enterConference();
 763         void leaveConference();
 764
 765         void addToConference(LinphoneCall call);
 766         void addAllToConference();
 767         void removeFromConference(LinphoneCall call);
 768
 769         void terminateConference();
 770         int getConferenceSize();
 771
 772         void terminateAllCalls();
 773         LinphoneCall[] getCalls();
 774         int getCallsNb();
 775
 776
 777         void transferCall(LinphoneCall call, String referTo);
 778         void transferCallToAnother(LinphoneCall callToTransfer, LinphoneCall destination);
 779
 780         LinphoneCall findCallFromUri(String uri);
 781
 782         int getMaxCalls();
 783         void setMaxCalls(int max);
 784         boolean isMyself(String uri);
 785
 786         /**
 787          * Use this method to check the calls state and forbid proposing actions
 788          * which could result in an active call.
 789          * Eg: don't start a new call if one is in outgoing ringing.
 790          * Eg: don't merge to conference either as it could result
 791          *     in two active calls (conference and accepted call).
 792          * @return
 793          */
 794         boolean soundResourcesLocked();
 795         /**
 796          * Returns whether given media encryption is supported by liblinphone.
 797          */
 798         boolean mediaEncryptionSupported(MediaEncryption menc);
 799         /**
 800          * set media encryption (rtp) to use
 801          * @params menc: MediaEncryption.None, MediaEncryption.SRTP or MediaEncryption.ZRTP
 802          */
 803         void setMediaEncryption(MediaEncryption menc);
 804         /**
 805          * return selected media encryption
 806          * @return MediaEncryption.None, MediaEncryption.SRTP or MediaEncryption.ZRTP
 807          */
 808         MediaEncryption getMediaEncryption();
 809 /**
 810          * Set media encryption required for outgoing calls
 811          */
 812         void setMediaEncryptionMandatory(boolean yesno);
 813         /**
 814          * @return if media encryption is required for outgoing calls
 815          */
 816         boolean isMediaEncryptionMandatory();
 817
 818         /**
 819          * @param path path to music file played to remote side when on hold.
 820          */
 821         void setPlayFile(String path);
 822         void tunnelEnable(boolean enable);
 823         void tunnelAutoDetect();
 824         void tunnelCleanServers();
 825         void tunnelSetHttpProxy(String proxy_host, int port, String username, String password);
 826         /**
 827          * @param host tunnel server ip address
 828          * @param port tunnel server tls port, recommended value is 443
 829          * @param udpMirrorPort remote port on the tunnel server side  used to test udp reachability
 830          * @param roundTripDelay udp packet round trip delay in ms considered as acceptable. recommended value is 1000 ms
 831          */
 832         void tunnelAddServerAndMirror(String host, int port, int udpMirrorPort, int roundTripDelay);
 833
 834         boolean isTunnelAvailable();
 835
 836         LinphoneProxyConfig[] getProxyConfigList();
 837
 838         void setVideoPolicy(boolean autoInitiate, boolean autoAccept);
 839
 840         void setStaticPicture(String path);
 841
 842         void setUserAgent(String name, String version);
 843
 844         void setCpuCount(int count);
 845
 846         /**
 847          * remove a call log
 848          */
 849         public void removeCallLog(LinphoneCallLog log);
 850
 851         /**
 852          * @return count of missed calls
 853          */
 854         public int getMissedCallsCount();
 855
 856         /**
 857          * Set missed calls count to zero
 858          */
 859         public void resetMissedCallsCount();
 860         /**
 861          * re-initiates registration if network is up.
 862          */
 863         public void refreshRegisters();
 864
 865         /**
 866          * return the version code of linphone core
 867          */
 868         public String getVersion();
 869
 870         /**
 871          * remove a linphone friend from linphone core and linphonerc
 872          */
 873         void removeFriend(LinphoneFriend lf);
 874
 875         /**
 876          * return a linphone friend (if exists) that matches the sip address
 877          */
 878         LinphoneFriend findFriendByAddress(String sipUri);
 879
 880         /**
 881          * Sets the UDP port used for audio streaming.
 882         **/
 883         void setAudioPort(int port);
 884
 885         /**
 886          * Sets the UDP port range from which to randomly select the port used for audio streaming.
 887          */
 888         void setAudioPortRange(int minPort, int maxPort);
 889
 890         /**
 891          * Sets the UDP port used for video streaming.
 892         **/
 893         void setVideoPort(int port);
 894
 895         /**
 896          * Sets the UDP port range from which to randomly select the port used for video streaming.
 897          */
 898         void setVideoPortRange(int minPort, int maxPort);
 899
 900         /**
 901          * Set the incoming call timeout in seconds.
 902          * If an incoming call isn't answered for this timeout period, it is
 903          * automatically declined.
 904         **/
 905         void setIncomingTimeout(int timeout);
 906
 907         /**
 908          * Set the call timeout in seconds.
 909          * Once this time is elapsed (ringing included), the call is automatically hung up.
 910         **/
 911         void setInCallTimeout(int timeout);
 912
 913         void setMicrophoneGain(float gain);
 914
 915         /**
 916          * Set username and display name to use if no LinphoneProxyConfig configured
 917          */
 918         void setPrimaryContact(String displayName, String username);
 919
 920         /**
 921          * Enable/Disable the use of SIP INFO for DTMFs
 922          */
 923         void setUseSipInfoForDtmfs(boolean use);
 924
 925         /**
 926          * Enable/Disable the use of inband DTMFs
 927          */
 928         void setUseRfc2833ForDtmfs(boolean use);
 929
 930         /**
 931          * @return returns LpConfig object to read/write to the config file: usefull if you wish to extend
 932          * the config file with your own sections
 933          */
 934         LpConfig getConfig();
 935
 936
 937         /**
 938          * Return the availability of uPnP.
 939          *
 940          * @return true if uPnP is available otherwise return false.
 941          */
 942         public boolean upnpAvailable();
 943
 944         /**
 945          * Return the internal state of uPnP.
 946          *
 947          * @return an UpnpState.
 948          */
 949         public UpnpState getUpnpState();
 950
 951         /**
 952          * Return the external ip address of router.
 953          * In some cases the uPnP can have an external ip address but not a usable uPnP
 954          * (state different of Ok).
 955          *
 956          * @return a null terminated string containing the external ip address. If the
 957          * the external ip address is not available return null.
 958          */
 959         public String getUpnpExternalIpaddress();
 960
 961 }