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