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