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