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         /**
 283          * Set the context of creation of the LinphoneCore.
 284          */
 285         public void setContext(Object context);
 286
 287         /**
 288          * clear all added proxy configs
 289          */
 290         public void clearProxyConfigs();
 291         /**
 292          * Add a proxy configuration. This will start registration on the proxy, if registration is enabled.
 293          * @param proxyCfg
 294          * @throws LinphoneCoreException
 295          */
 296         public void addProxyConfig(LinphoneProxyConfig proxyCfg) throws LinphoneCoreException;
 297         /**
 298          * Sets the default proxy.
 299          *<br>
 300          * This default proxy must be part of the list of already entered {@link LinphoneProxyConfig}.
 301          * Toggling it as default will make LinphoneCore use the identity associated with the proxy configuration in all incoming and outgoing calls.
 302          * @param proxyCfg
 303          */
 304         public void setDefaultProxyConfig(LinphoneProxyConfig proxyCfg);
 305
 306         /**
 307          * get he default proxy configuration, that is the one used to determine the current identity.
 308          * @return null if no default proxy config
 309          */
 310         public LinphoneProxyConfig getDefaultProxyConfig() ;
 311
 312         /**
 313          * clear all the added auth info
 314          */
 315         void clearAuthInfos();
 316         /**
 317          * Adds authentication information to the LinphoneCore.
 318          * <br>This information will be used during all SIP transacations that require authentication.
 319          * @param info
 320          */
 321         void addAuthInfo(LinphoneAuthInfo info);
 322
 323         /**
 324          * Build an address according to the current proxy config. In case destination is not a sip address, the default proxy domain is automatically appended
 325          * @param destination
 326          * @return
 327          * @throws If no LinphoneAddress can be built from destination
 328          */
 329         public LinphoneAddress interpretUrl(String destination) throws LinphoneCoreException;
 330
 331         /**
 332          * Starts a call given a destination. Internally calls {@link #interpretUrl(String)} then {@link #invite(LinphoneAddress)}.
 333          * @param uri
 334          */
 335         public LinphoneCall invite(String destination)throws LinphoneCoreException;
 336         /**
 337          * Initiates an outgoing call given a destination LinphoneAddress
 338          *<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.
 339          * @param to the destination of the call (sip address).
 340          * @return LinphoneCall
 341          * @throws LinphoneCoreException
 342          */
 343         public LinphoneCall invite(LinphoneAddress to)throws LinphoneCoreException;
 344         /**
 345          * Terminates a call.
 346          * @param aCall to be terminated
 347          */
 348         public void terminateCall(LinphoneCall aCall);
 349         /**
 350          * Returns The LinphoneCall the current call if one is in call
 351          *
 352         **/
 353         public LinphoneCall getCurrentCall();
 354
 355         /**
 356          * get current call remote address in case of in/out call
 357          * @return null if no call engaged yet
 358          */
 359         public LinphoneAddress getRemoteAddress();
 360         /**
 361          *
 362          * @return  TRUE if there is a call running or pending.
 363          */
 364         public boolean isIncall();
 365         /**
 366          *
 367          * @return Returns true if in incoming call is pending, ie waiting for being answered or declined.
 368          */
 369         public boolean isInComingInvitePending();
 370         /**
 371          * Main loop function. It is crucial that your application call it periodically.
 372          *
 373          *      #iterate() performs various backgrounds tasks:
 374          * <li>receiving of SIP messages
 375          * <li> handles timers and timeout
 376          * <li> performs registration to proxies
 377          * <li> authentication retries The application MUST call this function from periodically, in its main loop.
 378          * <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.
 379
 380          */
 381         public void iterate();
 382         /**
 383          * Accept an incoming call.
 384          *
 385          * Basically the application is notified of incoming calls within the
 386          * {@link LinphoneCoreListener#callState} listener method.
 387          * The application can later respond positively to the call using
 388          * this method.
 389          * @throws LinphoneCoreException
 390          */
 391         public void acceptCall(LinphoneCall aCall) throws LinphoneCoreException;
 392
 393         /**
 394          * Accept an incoming call.
 395          *
 396          * Basically the application is notified of incoming calls within the
 397          * {@link LinphoneCoreListener#callState} listener method.
 398          * The application can later respond positively to the call using
 399          * this method.
 400          * @throws LinphoneCoreException
 401          */
 402         public void acceptCallWithParams(LinphoneCall aCall, LinphoneCallParams params) throws LinphoneCoreException;
 403
 404         /**
 405          * Accept call modifications initiated by other end.
 406          *
 407          * Basically the application is notified of incoming calls within the
 408          * {@link LinphoneCoreListener#callState} listener method.
 409          * The application can later respond positively to the call using
 410          * this method.
 411          * @throws LinphoneCoreException
 412          */
 413         public void acceptCallUpdate(LinphoneCall aCall, LinphoneCallParams params) throws LinphoneCoreException;
 414
 415
 416         /**
 417          * Prevent LinphoneCore from performing an automatic answer
 418          *
 419          * Basically the application is notified of incoming calls within the
 420          * {@link LinphoneCoreListener#callState} listener method.
 421          * The application can later respond positively to the call using
 422          * this method.
 423          * @throws LinphoneCoreException
 424          */
 425         public void deferCallUpdate(LinphoneCall aCall) throws LinphoneCoreException;
 426
 427         public void startRinging();
 428
 429         /**
 430          * @return a list of LinphoneCallLog
 431          */
 432         public LinphoneCallLog[] getCallLogs();
 433
 434         /**
 435          * This method is called by the application to notify the Linphone core library when network is reachable.
 436          * Calling this method with true trigger Linphone to initiate a registration process for all proxy
 437          * configuration with parameter register set to enable.
 438          * This method disable the automatic registration mode. It means you must call this method after each network state changes
 439          * @param network state
 440          *
 441          */
 442         public void setNetworkReachable(boolean isReachable);
 443         /**
 444          *
 445          * @return if false, there is no network connection.
 446          */
 447         public boolean isNetworkReachable();
 448         /**
 449          * destroy linphone core and free all underlying resources
 450          */
 451         public void destroy();
 452         /**
 453          * Allow to control play level before entering  sound card:
 454          * @param level in db
 455          */
 456         public void setPlaybackGain(float gain);
 457         /**
 458          * get play level before entering  sound card:
 459          * @return level in db
 460          */
 461         public float getPlaybackGain();
 462         /**
 463          * set play level
 464          * @param level [0..100]
 465          */
 466         public void setPlayLevel(int level);
 467         /**
 468          * get playback level [0..100];
 469          * -1 if not cannot be determined
 470          * @return
 471          */
 472         public int getPlayLevel();
 473         /**
 474          *  Mutes or unmutes the local microphone.
 475          * @param isMuted
 476          */
 477         void muteMic(boolean isMuted);
 478         /**
 479          *
 480          * @return true is mic is muted
 481          */
 482         boolean isMicMuted();
 483
 484         /**
 485          * Initiate a dtmf signal if in call
 486          * @param number
 487          */
 488         void sendDtmf(char number);
 489         /**
 490          * Initiate a dtmf signal to the speaker if not in call.
 491          * Sending of the DTMF is done in another function.
 492          * @param number
 493          * @param duration in ms , -1 for unlimited
 494          */
 495         void playDtmf(char number,int duration);
 496         /**
 497          * stop current dtmf
 498          */
 499         void stopDtmf();
 500
 501         /**
 502          * remove all call logs
 503          */
 504         void clearCallLogs();
 505         /***
 506          * get payload type  from mime type, clock rate, and number of channels.-
 507          *
 508          * return null if not found
 509          */
 510         PayloadType findPayloadType(String mime, int clockRate, int channels);
 511         /***
 512          * get payload type  from mime type and clock rate..
 513          *
 514          * return null if not found
 515          */
 516         PayloadType findPayloadType(String mime, int clockRate);
 517         /**
 518          * not implemented yet
 519          * @param pt
 520          * @param enable
 521          * @throws LinphoneCoreException
 522          */
 523         void enablePayloadType(PayloadType pt, boolean enable) throws LinphoneCoreException;
 524         /**
 525          * Enables or disable echo cancellation.
 526          * @param enable
 527          */
 528         void enableEchoCancellation(boolean enable);
 529         /**
 530          * get EC status
 531          * @return true if echo cancellation is enabled.
 532          */
 533         boolean isEchoCancellationEnabled();
 534         /**
 535          * Get echo limiter status (another method of doing echo suppression, more brute force)
 536          * @return true if echo limiter is enabled
 537          */
 538         boolean isEchoLimiterEnabled();
 539         /**
 540          * @param transports used for signaling (TCP, UDP and TLS)
 541          */
 542         void setSignalingTransportPorts(Transports transports);
 543         /**
 544          * @return transports used for signaling (TCP, UDP, TLS)
 545          */
 546         Transports getSignalingTransportPorts();
 547         /**
 548          * Activates or deactivates the speaker.
 549          * @param value
 550          */
 551         void enableSpeaker(boolean value);
 552         /**
 553          * Tells whether the speaker is activated.
 554          * @return true if speaker enabled, false otherwise
 555          */
 556         boolean isSpeakerEnabled();
 557         /**
 558          * add a friend to the current buddy list, if subscription attribute is set, a SIP SUBSCRIBE message is sent.
 559          * @param lf LinphoenFriend to add
 560          * @throws LinphoneCoreException
 561          */
 562         void addFriend(LinphoneFriend lf) throws LinphoneCoreException;
 563
 564         /**
 565          * Set my presence status
 566          * @param minute_away how long in away
 567          * @param status sip uri used to redirect call in state LinphoneStatusMoved
 568          */
 569         void setPresenceInfo(int minute_away,String alternative_contact, OnlineStatus status);
 570         /**
 571          * Create a new chat room for messaging from a sip uri like sip:joe@sip.linphone.org
 572          * @param to    destination address for messages
 573          *
 574          * @return {@link LinphoneChatRoom} where messaging can take place.
 575          */
 576         LinphoneChatRoom createChatRoom(String to);
 577
 578         void setVideoWindow(Object w);
 579         void setPreviewWindow(Object w);
 580         void setDeviceRotation(int rotation);
 581
 582         void setVideoDevice(int id);
 583         int getVideoDevice();
 584
 585         /**
 586          * Enables video globally.
 587          *
 588          *
 589          * This function does not have any effect during calls. It just indicates #LinphoneCore to
 590          * initiate future calls with video or not. The two boolean parameters indicate in which
 591          * direction video is enabled. Setting both to false disables video entirely.
 592          *
 593          * @param vcap_enabled indicates whether video capture is enabled
 594          * @param display_enabled indicates whether video display should be shown
 595          *
 596         **/
 597         void enableVideo(boolean vcap_enabled, boolean display_enabled);
 598         /**
 599          * Returns TRUE if video is enabled, FALSE otherwise.
 600          *
 601          ***/
 602         boolean isVideoEnabled();
 603
 604         /**
 605          * Specify a STUN server to help firewall traversal.
 606          * @param stun_server Stun server address and port, such as stun.linphone.org or stun.linphone.org:3478
 607          */
 608         void setStunServer(String stun_server);
 609         /**
 610          * @return stun server address if previously set.
 611          */
 612         String getStunServer();
 613
 614         /**
 615          * Sets policy regarding workarounding NATs
 616          * @param pol one of the FirewallPolicy members.
 617         **/
 618         void setFirewallPolicy(FirewallPolicy pol);
 619         /**
 620          * @return previously set firewall policy.
 621          */
 622         FirewallPolicy getFirewallPolicy();
 623
 624         LinphoneCall inviteAddressWithParams(LinphoneAddress destination, LinphoneCallParams params) throws LinphoneCoreException ;
 625
 626         int updateCall(LinphoneCall call, LinphoneCallParams params);
 627
 628         LinphoneCallParams createDefaultCallParameters();
 629
 630         /**
 631          * Sets the path to a wav file used for ringing.
 632          *
 633          * @param path The file must be a wav 16bit linear. Local ring is disabled if null
 634          */
 635         void setRing(String path);
 636         /**
 637          * gets the path to a wav file used for ringing.
 638          *
 639          * @param null if not set
 640          */
 641         String getRing();
 642
 643         /**
 644          * Sets file or folder containing trusted root CAs
 645          *
 646          * @param path path to file with multiple PEM certif or to folder with multiple PEM files
 647          */
 648         void setRootCA(String path);
 649
 650         void setUploadBandwidth(int bw);
 651
 652         void setDownloadBandwidth(int bw);
 653
 654         /**
 655          * Sets audio packetization interval suggested for remote end.
 656          * @param ptime packetization interval in milliseconds
 657          */
 658         void setDownloadPtime(int ptime);
 659
 660         /**
 661          * Sets audio packetization interval sent to remote end.
 662          * @param ptime packetization interval in milliseconds
 663          */
 664         void setUploadPtime(int ptime);
 665
 666         void setPreferredVideoSize(VideoSize vSize);
 667
 668         VideoSize getPreferredVideoSize();
 669
 670         /**
 671          * Returns the currently supported audio codecs, as PayloadType elements
 672          * @return
 673          */
 674         PayloadType[] getAudioCodecs();
 675         /**
 676          * Returns the currently supported video codecs, as PayloadType elements
 677          * @return
 678          */
 679         PayloadType[] getVideoCodecs();
 680         /**
 681          * enable signaling keep alive. small udp packet sent periodically to keep udp NAT association
 682          */
 683         void enableKeepAlive(boolean enable);
 684         /**
 685          * get keep elive mode
 686          * @return true if enable
 687          */
 688         boolean isKeepAliveEnabled();
 689         /**
 690          * Start an echo calibration of the sound devices, in order to find adequate settings for the echo canceler automatically.
 691          * status is notified to {@link LinphoneCoreListener#ecCalibrationStatus(EcCalibratorStatus, int, Object)}
 692          * @param User object
 693          * @throws LinphoneCoreException if operation is still in progress;
 694         **/
 695         void startEchoCalibration(Object data) throws LinphoneCoreException;
 696
 697         void enableIpv6(boolean enable);
 698         /**
 699          * @deprecated
 700          * @param i
 701          */
 702         void adjustSoftwareVolume(int i);
 703
 704         boolean pauseCall(LinphoneCall call);
 705         boolean resumeCall(LinphoneCall call);
 706         boolean pauseAllCalls();
 707
 708         void setZrtpSecretsCache(String file);
 709         void enableEchoLimiter(boolean val);
 710
 711         boolean isInConference();
 712         boolean enterConference();
 713         void leaveConference();
 714
 715         void addToConference(LinphoneCall call);
 716         void addAllToConference();
 717         void removeFromConference(LinphoneCall call);
 718
 719         void terminateConference();
 720         int getConferenceSize();
 721
 722         void terminateAllCalls();
 723         LinphoneCall[] getCalls();
 724         int getCallsNb();
 725
 726
 727         void transferCall(LinphoneCall call, String referTo);
 728         void transferCallToAnother(LinphoneCall callToTransfer, LinphoneCall destination);
 729
 730         LinphoneCall findCallFromUri(String uri);
 731
 732         int getMaxCalls();
 733         void setMaxCalls(int max);
 734         boolean isMyself(String uri);
 735
 736         /**
 737          * Use this method to check the calls state and forbid proposing actions
 738          * which could result in an active call.
 739          * Eg: don't start a new call if one is in outgoing ringing.
 740          * Eg: don't merge to conference either as it could result
 741          *     in two active calls (conference and accepted call).
 742          * @return
 743          */
 744         boolean soundResourcesLocked();
 745         /**
 746          * Returns whether given media encryption is supported by liblinphone.
 747          */
 748         boolean mediaEncryptionSupported(MediaEncryption menc);
 749         /**
 750          * set media encryption (rtp) to use
 751          * @params menc: MediaEncryption.None, MediaEncryption.SRTP or MediaEncryption.ZRTP
 752          */
 753         void setMediaEncryption(MediaEncryption menc);
 754         /**
 755          * return selected media encryption
 756          * @return MediaEncryption.None, MediaEncryption.SRTP or MediaEncryption.ZRTP
 757          */
 758         MediaEncryption getMediaEncryption();
 759 /**
 760          * Set media encryption required for outgoing calls
 761          */
 762         void setMediaEncryptionMandatory(boolean yesno);
 763         /**
 764          * @return if media encryption is required for outgoing calls
 765          */
 766         boolean isMediaEncryptionMandatory();
 767
 768         /**
 769          * @param path path to music file played to remote side when on hold.
 770          */
 771         void setPlayFile(String path);
 772         void tunnelEnable(boolean enable);
 773         void tunnelAutoDetect();
 774         void tunnelCleanServers();
 775         void tunnelSetHttpProxy(String proxy_host, int port, String username, String password);
 776         /**
 777          * @param host tunnel server ip address
 778          * @param port tunnel server tls port, recommended value is 443
 779          * @param udpMirrorPort remote port on the tunnel server side  used to test udp reachability
 780          * @param roundTripDelay udp packet round trip delay in ms considered as acceptable. recommended value is 1000 ms
 781          */
 782         void tunnelAddServerAndMirror(String host, int port, int udpMirrorPort, int roundTripDelay);
 783
 784         boolean isTunnelAvailable();
 785
 786         LinphoneProxyConfig[] getProxyConfigList();
 787
 788         void setVideoPolicy(boolean autoInitiate, boolean autoAccept);
 789
 790         void setStaticPicture(String path);
 791
 792         void setUserAgent(String name, String version);
 793
 794         void setCpuCount(int count);
 795
 796         /**
 797          * remove a call log
 798          */
 799         public void removeCallLog(LinphoneCallLog log);
 800
 801         /**
 802          * @return count of missed calls
 803          */
 804         public int getMissedCallsCount();
 805
 806         /**
 807          * Set missed calls count to zero
 808          */
 809         public void resetMissedCallsCount();
 810         /**
 811          * re-initiates registration if network is up.
 812          */
 813         public void refreshRegisters();
 814
 815         /**
 816          * return the version code of linphone core
 817          */
 818         public String getVersion();
 819
 820         /**
 821          * remove a linphone friend from linphone core and linphonerc
 822          */
 823         void removeFriend(LinphoneFriend lf);
 824
 825         /**
 826          * return a linphone friend (if exists) that matches the sip address
 827          */
 828         LinphoneFriend findFriendByAddress(String sipUri);
 829
 830         /**
 831          * Sets the UDP port used for audio streaming.
 832         **/
 833         void setAudioPort(int port);
 834
 835         /**
 836          * Sets the UDP port range from which to randomly select the port used for audio streaming.
 837          */
 838         void setAudioPortRange(int minPort, int maxPort);
 839
 840         /**
 841          * Sets the UDP port used for video streaming.
 842         **/
 843         void setVideoPort(int port);
 844
 845         /**
 846          * Sets the UDP port range from which to randomly select the port used for video streaming.
 847          */
 848         void setVideoPortRange(int minPort, int maxPort);
 849
 850         /**
 851          * Set the incoming call timeout in seconds.
 852          * If an incoming call isn't answered for this timeout period, it is
 853          * automatically declined.
 854         **/
 855         void setIncomingTimeout(int timeout);
 856
 857         /**
 858          * Set the call timeout in seconds.
 859          * Once this time is elapsed (ringing included), the call is automatically hung up.
 860         **/
 861         void setInCallTimeout(int timeout);
 862
 863         void setMicrophoneGain(float gain);
 864
 865         /**
 866          * Set username and display name to use if no LinphoneProxyConfig configured
 867          */
 868         void setPrimaryContact(String displayName, String username);
 869
 870         /**
 871          * Enable/Disable the use of SIP INFO for DTMFs
 872          */
 873         void setUseSipInfoForDtmfs(boolean use);
 874
 875         /**
 876          * Enable/Disable the use of inband DTMFs
 877          */
 878         void setUseRfc2833ForDtmfs(boolean use);
 879
 880         /**
 881          * @return returns LpConfig object to read/write to the config file: usefull if you wish to extend
 882          * the config file with your own sections
 883          */
 884         LpConfig getConfig();
 885 }