sjero.net Git - linphone/blob - java/impl/org/linphone/core/LinphoneCoreImpl.java

   1 /*
   2 LinphoneCoreImpl.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.io.File;
  22 import java.io.IOException;
  23
  24
  25 class LinphoneCoreImpl implements LinphoneCore {
  26
  27         private final  LinphoneCoreListener mListener; //to make sure to keep a reference on this object
  28         private long nativePtr = 0;
  29         private native long newLinphoneCore(LinphoneCoreListener listener,String userConfig,String factoryConfig,Object  userdata);
  30         private native void iterate(long nativePtr);
  31         private native long getDefaultProxyConfig(long nativePtr);
  32
  33         private native void setDefaultProxyConfig(long nativePtr,long proxyCfgNativePtr);
  34         private native int addProxyConfig(LinphoneProxyConfig jprtoxyCfg,long nativePtr,long proxyCfgNativePtr);
  35         private native void clearAuthInfos(long nativePtr);
  36
  37         private native void clearProxyConfigs(long nativePtr);
  38         private native void addAuthInfo(long nativePtr,long authInfoNativePtr);
  39         private native Object invite(long nativePtr,String uri);
  40         private native void terminateCall(long nativePtr, long call);
  41         private native long getRemoteAddress(long nativePtr);
  42         private native boolean  isInCall(long nativePtr);
  43         private native boolean isInComingInvitePending(long nativePtr);
  44         private native void acceptCall(long nativePtr, long call);
  45         private native long getCallLog(long nativePtr,int position);
  46         private native int getNumberOfCallLogs(long nativePtr);
  47         private native void delete(long nativePtr);
  48         private native void setNetworkStateReachable(long nativePtr,boolean isReachable);
  49         private native boolean isNetworkStateReachable(long nativePtr);
  50         private native void setPlaybackGain(long nativeptr, float gain);
  51         private native float getPlaybackGain(long nativeptr);
  52         private native void muteMic(long nativePtr,boolean isMuted);
  53         private native long interpretUrl(long nativePtr,String destination);
  54         private native Object inviteAddress(long nativePtr,long to);
  55         private native Object inviteAddressWithParams(long nativePtrLc,long to, long nativePtrParam);
  56         private native void sendDtmf(long nativePtr,char dtmf);
  57         private native void clearCallLogs(long nativePtr);
  58         private native boolean isMicMuted(long nativePtr);
  59         private native long findPayloadType(long nativePtr, String mime, int clockRate, int channels);
  60         private native int enablePayloadType(long nativePtr, long payloadType,  boolean enable);
  61         private native void enableEchoCancellation(long nativePtr,boolean enable);
  62         private native boolean isEchoCancellationEnabled(long nativePtr);
  63         private native Object getCurrentCall(long nativePtr) ;
  64         private native void playDtmf(long nativePtr,char dtmf,int duration);
  65         private native void stopDtmf(long nativePtr);
  66         private native void setVideoWindowId(long nativePtr, Object wid);
  67         private native void setPreviewWindowId(long nativePtr, Object wid);
  68         private native void setDeviceRotation(long nativePtr, int rotation);
  69         private native void addFriend(long nativePtr,long friend);
  70         private native void setPresenceInfo(long nativePtr,int minute_away, String alternative_contact,int status);
  71         private native long createChatRoom(long nativePtr,String to);
  72         private native void enableVideo(long nativePtr,boolean vcap_enabled,boolean display_enabled);
  73         private native boolean isVideoEnabled(long nativePtr);
  74         private native void setFirewallPolicy(long nativePtr, int enum_value);
  75         private native int getFirewallPolicy(long nativePtr);
  76         private native void setStunServer(long nativePtr, String stun_server);
  77         private native String getStunServer(long nativePtr);
  78         private native long createDefaultCallParams(long nativePtr);
  79         private native int updateCall(long ptrLc, long ptrCall, long ptrParams);
  80         private native void setUploadBandwidth(long nativePtr, int bw);
  81         private native void setDownloadBandwidth(long nativePtr, int bw);
  82         private native void setPreferredVideoSize(long nativePtr, int width, int heigth);
  83         private native int[] getPreferredVideoSize(long nativePtr);
  84         private native void setRing(long nativePtr, String path);
  85         private native String getRing(long nativePtr);
  86         private native void setRootCA(long nativePtr, String path);
  87         private native long[] listVideoPayloadTypes(long nativePtr);
  88         private native long[] getProxyConfigList(long nativePtr);
  89         private native long[] listAudioPayloadTypes(long nativePtr);
  90         private native void enableKeepAlive(long nativePtr,boolean enable);
  91         private native boolean isKeepAliveEnabled(long nativePtr);
  92         private native int startEchoCalibration(long nativePtr,Object data);
  93         private native int getSignalingTransportPort(long nativePtr, int code);
  94         private native void setSignalingTransportPorts(long nativePtr, int udp, int tcp, int tls);
  95         private native void enableIpv6(long nativePtr,boolean enable);
  96         private native int pauseCall(long nativePtr, long callPtr);
  97         private native int pauseAllCalls(long nativePtr);
  98         private native int resumeCall(long nativePtr, long callPtr);
  99         private native void setUploadPtime(long nativePtr, int ptime);
 100         private native void setDownloadPtime(long nativePtr, int ptime);
 101         private native void setZrtpSecretsCache(long nativePtr, String file);
 102         private native void enableEchoLimiter(long nativePtr2, boolean val);
 103         private native int setVideoDevice(long nativePtr2, int id);
 104         private native int getVideoDevice(long nativePtr2);
 105         private native int getMediaEncryption(long nativePtr);
 106         private native void setMediaEncryption(long nativePtr, int menc);
 107         private native boolean isMediaEncryptionMandatory(long nativePtr);
 108         private native void setMediaEncryptionMandatory(long nativePtr, boolean yesno);
 109         private native void removeCallLog(long nativePtr, long callLogPtr);
 110         private native int getMissedCallsCount(long nativePtr);
 111         private native void resetMissedCallsCount(long nativePtr);
 112         private native String getVersion(long nativePtr);
 113         private native void setAudioPort(long nativePtr, int port);
 114         private native void setVideoPort(long nativePtr, int port);
 115         private native void setAudioPortRange(long nativePtr, int minPort, int maxPort);
 116         private native void setVideoPortRange(long nativePtr, int minPort, int maxPort);
 117         private native void setIncomingTimeout(long nativePtr, int timeout);
 118         private native void setInCallTimeout(long nativePtr, int timeout);
 119         private native void setPrimaryContact(long nativePtr, String displayName, String username);
 120
 121         LinphoneCoreImpl(LinphoneCoreListener listener, File userConfig,File factoryConfig,Object  userdata) throws IOException {
 122                 mListener=listener;
 123                 nativePtr = newLinphoneCore(listener,userConfig.getCanonicalPath(),factoryConfig.getCanonicalPath(),userdata);
 124         }
 125         LinphoneCoreImpl(LinphoneCoreListener listener) throws IOException {
 126                 mListener=listener;
 127                 nativePtr = newLinphoneCore(listener,null,null,null);
 128         }
 129
 130         protected void finalize() throws Throwable {
 131
 132         }
 133
 134         public synchronized void addAuthInfo(LinphoneAuthInfo info) {
 135                 isValid();
 136                 addAuthInfo(nativePtr,((LinphoneAuthInfoImpl)info).nativePtr);
 137         }
 138
 139
 140
 141         public synchronized LinphoneProxyConfig getDefaultProxyConfig() {
 142                 isValid();
 143                 long lNativePtr = getDefaultProxyConfig(nativePtr);
 144                 if (lNativePtr!=0) {
 145                         return new LinphoneProxyConfigImpl(lNativePtr);
 146                 } else {
 147                         return null;
 148                 }
 149         }
 150
 151         public synchronized LinphoneCall invite(String uri) {
 152                 isValid();
 153                 return (LinphoneCall)invite(nativePtr,uri);
 154         }
 155
 156         public synchronized void iterate() {
 157                 isValid();
 158                 iterate(nativePtr);
 159         }
 160
 161         public synchronized void setDefaultProxyConfig(LinphoneProxyConfig proxyCfg) {
 162                 isValid();
 163                 setDefaultProxyConfig(nativePtr,((LinphoneProxyConfigImpl)proxyCfg).nativePtr);
 164         }
 165         public synchronized void addProxyConfig(LinphoneProxyConfig proxyCfg) throws LinphoneCoreException{
 166                 isValid();
 167                 if (addProxyConfig(proxyCfg,nativePtr,((LinphoneProxyConfigImpl)proxyCfg).nativePtr) !=0) {
 168                         throw new LinphoneCoreException("bad proxy config");
 169                 }
 170         }
 171         public synchronized void clearAuthInfos() {
 172                 isValid();
 173                 clearAuthInfos(nativePtr);
 174
 175         }
 176         public synchronized void clearProxyConfigs() {
 177                 isValid();
 178                 clearProxyConfigs(nativePtr);
 179         }
 180         public synchronized void terminateCall(LinphoneCall aCall) {
 181                 isValid();
 182                 if (aCall!=null)terminateCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr);
 183         }
 184         public synchronized LinphoneAddress getRemoteAddress() {
 185                 isValid();
 186                 long ptr = getRemoteAddress(nativePtr);
 187                 if (ptr==0) {
 188                         return null;
 189                 } else {
 190                         return new LinphoneAddressImpl(ptr);
 191                 }
 192         }
 193         public synchronized  boolean isIncall() {
 194                 isValid();
 195                 return isInCall(nativePtr);
 196         }
 197         public synchronized boolean isInComingInvitePending() {
 198                 isValid();
 199                 return isInComingInvitePending(nativePtr);
 200         }
 201         public synchronized void acceptCall(LinphoneCall aCall) {
 202                 isValid();
 203                 acceptCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr);
 204
 205         }
 206         public synchronized LinphoneCallLog[] getCallLogs() {
 207                 isValid();
 208                 LinphoneCallLog[] logs = new LinphoneCallLog[getNumberOfCallLogs(nativePtr)];
 209                 for (int i=0;i < getNumberOfCallLogs(nativePtr);i++) {
 210                         logs[i] = new LinphoneCallLogImpl(getCallLog(nativePtr, i));
 211                 }
 212                 return logs;
 213         }
 214         public synchronized void destroy() {
 215                 isValid();
 216                 delete(nativePtr);
 217                 nativePtr = 0;
 218         }
 219
 220         private void isValid() {
 221                 if (nativePtr == 0) {
 222                         throw new RuntimeException("object already destroyed");
 223                 }
 224         }
 225         public synchronized void setNetworkReachable(boolean isReachable) {
 226                 setNetworkStateReachable(nativePtr,isReachable);
 227         }
 228         public synchronized void setPlaybackGain(float gain) {
 229                 setPlaybackGain(nativePtr,gain);
 230
 231         }
 232         public synchronized float getPlaybackGain() {
 233                 return getPlaybackGain(nativePtr);
 234         }
 235         public synchronized void muteMic(boolean isMuted) {
 236                 muteMic(nativePtr,isMuted);
 237         }
 238         public synchronized LinphoneAddress interpretUrl(String destination) throws LinphoneCoreException {
 239                 long lAddress = interpretUrl(nativePtr,destination);
 240                 if (lAddress != 0) {
 241                         return new LinphoneAddressImpl(lAddress,true);
 242                 } else {
 243                         throw new LinphoneCoreException("Cannot interpret ["+destination+"]");
 244                 }
 245         }
 246         public synchronized LinphoneCall invite(LinphoneAddress to) throws LinphoneCoreException {
 247                 LinphoneCall call = (LinphoneCall)inviteAddress(nativePtr,((LinphoneAddressImpl)to).nativePtr);
 248                 if (call!=null) {
 249                         return call;
 250                 } else {
 251                         throw new LinphoneCoreException("Unable to invite address " + to.asString());
 252                 }
 253         }
 254
 255         public synchronized void sendDtmf(char number) {
 256                 sendDtmf(nativePtr,number);
 257         }
 258         public synchronized void clearCallLogs() {
 259                 clearCallLogs(nativePtr);
 260         }
 261         public synchronized boolean isMicMuted() {
 262                 return isMicMuted(nativePtr);
 263         }
 264         public synchronized PayloadType findPayloadType(String mime, int clockRate, int channels) {
 265                 isValid();
 266                 long playLoadType = findPayloadType(nativePtr, mime, clockRate, channels);
 267                 if (playLoadType == 0) {
 268                         return null;
 269                 } else {
 270                         return new PayloadTypeImpl(playLoadType);
 271                 }
 272         }
 273         public synchronized void enablePayloadType(PayloadType pt, boolean enable)
 274                         throws LinphoneCoreException {
 275                 isValid();
 276                 if (enablePayloadType(nativePtr,((PayloadTypeImpl)pt).nativePtr,enable) != 0) {
 277                         throw new LinphoneCoreException("cannot enable payload type ["+pt+"]");
 278                 }
 279
 280         }
 281         public synchronized void enableEchoCancellation(boolean enable) {
 282                 isValid();
 283                 enableEchoCancellation(nativePtr, enable);
 284         }
 285         public synchronized boolean isEchoCancellationEnabled() {
 286                 isValid();
 287                 return isEchoCancellationEnabled(nativePtr);
 288
 289         }
 290
 291         public synchronized LinphoneCall getCurrentCall() {
 292                 isValid();
 293                 return (LinphoneCall)getCurrentCall(nativePtr);
 294         }
 295
 296         public int getPlayLevel() {
 297                 // TODO Auto-generated method stub
 298                 return 0;
 299         }
 300         public void setPlayLevel(int level) {
 301                 // TODO Auto-generated method stub
 302
 303         }
 304         public void enableSpeaker(boolean value) {
 305                 // TODO Auto-generated method stub
 306
 307         }
 308         public boolean isSpeakerEnabled() {
 309                 // TODO Auto-generated method stub
 310                 return false;
 311         }
 312         public synchronized void playDtmf(char number, int duration) {
 313                 playDtmf(nativePtr,number, duration);
 314
 315         }
 316         public synchronized void stopDtmf() {
 317                 stopDtmf(nativePtr);
 318         }
 319
 320         public synchronized void addFriend(LinphoneFriend lf) throws LinphoneCoreException {
 321                 addFriend(nativePtr,((LinphoneFriendImpl)lf).nativePtr);
 322
 323         }
 324         public synchronized void setPresenceInfo(int minute_away, String alternative_contact,
 325                         OnlineStatus status) {
 326                 setPresenceInfo(nativePtr,minute_away,alternative_contact,status.mValue);
 327
 328         }
 329         public synchronized LinphoneChatRoom createChatRoom(String to) {
 330                 return new LinphoneChatRoomImpl(createChatRoom(nativePtr,to));
 331         }
 332         public synchronized void setPreviewWindow(Object w) {
 333                 setPreviewWindowId(nativePtr,w);
 334         }
 335         public synchronized void setVideoWindow(Object w) {
 336                 setVideoWindowId(nativePtr, w);
 337         }
 338         public synchronized void setDeviceRotation(int rotation) {
 339                 setDeviceRotation(nativePtr, rotation);
 340         }
 341
 342         public synchronized void enableVideo(boolean vcap_enabled, boolean display_enabled) {
 343                 enableVideo(nativePtr,vcap_enabled, display_enabled);
 344         }
 345         public synchronized boolean isVideoEnabled() {
 346                 return isVideoEnabled(nativePtr);
 347         }
 348         public synchronized FirewallPolicy getFirewallPolicy() {
 349                 return FirewallPolicy.fromInt(getFirewallPolicy(nativePtr));
 350         }
 351         public synchronized String getStunServer() {
 352                 return getStunServer(nativePtr);
 353         }
 354         public synchronized void setFirewallPolicy(FirewallPolicy pol) {
 355                 setFirewallPolicy(nativePtr,pol.value());
 356         }
 357         public synchronized void setStunServer(String stunServer) {
 358                 setStunServer(nativePtr,stunServer);
 359         }
 360
 361         public synchronized LinphoneCallParams createDefaultCallParameters() {
 362                 return new LinphoneCallParamsImpl(createDefaultCallParams(nativePtr));
 363         }
 364
 365         public synchronized LinphoneCall inviteAddressWithParams(LinphoneAddress to, LinphoneCallParams params) throws LinphoneCoreException {
 366                 long ptrDestination = ((LinphoneAddressImpl)to).nativePtr;
 367                 long ptrParams =((LinphoneCallParamsImpl)params).nativePtr;
 368
 369                 LinphoneCall call = (LinphoneCall)inviteAddressWithParams(nativePtr, ptrDestination, ptrParams);
 370                 if (call!=null) {
 371                         return call;
 372                 } else {
 373                         throw new LinphoneCoreException("Unable to invite with params " + to.asString());
 374                 }
 375         }
 376
 377         public synchronized int updateCall(LinphoneCall call, LinphoneCallParams params) {
 378                 long ptrCall = ((LinphoneCallImpl) call).nativePtr;
 379                 long ptrParams = params!=null ? ((LinphoneCallParamsImpl)params).nativePtr : 0;
 380
 381                 return updateCall(nativePtr, ptrCall, ptrParams);
 382         }
 383         public synchronized void setUploadBandwidth(int bw) {
 384                 setUploadBandwidth(nativePtr, bw);
 385         }
 386
 387         public synchronized void setDownloadBandwidth(int bw) {
 388                 setDownloadBandwidth(nativePtr, bw);
 389         }
 390
 391         public synchronized void setPreferredVideoSize(VideoSize vSize) {
 392                 setPreferredVideoSize(nativePtr, vSize.width, vSize.height);
 393         }
 394
 395         public synchronized VideoSize getPreferredVideoSize() {
 396                 int[] nativeSize = getPreferredVideoSize(nativePtr);
 397
 398                 VideoSize vSize = new VideoSize();
 399                 vSize.width = nativeSize[0];
 400                 vSize.height = nativeSize[1];
 401                 return vSize;
 402         }
 403         public synchronized void setRing(String path) {
 404                 setRing(nativePtr, path);
 405         }
 406         public synchronized String getRing() {
 407                 return getRing(nativePtr);
 408         }
 409
 410         public synchronized void setRootCA(String path) {
 411                 setRootCA(nativePtr, path);
 412         }
 413
 414         public synchronized LinphoneProxyConfig[] getProxyConfigList() {
 415                 long[] typesPtr = getProxyConfigList(nativePtr);
 416                 if (typesPtr == null) return null;
 417
 418                 LinphoneProxyConfig[] proxies = new LinphoneProxyConfig[typesPtr.length];
 419
 420                 for (int i=0; i < proxies.length; i++) {
 421                         proxies[i] = new LinphoneProxyConfigImpl(typesPtr[i]);
 422                 }
 423
 424                 return proxies;
 425         }
 426
 427         public synchronized PayloadType[] getVideoCodecs() {
 428                 long[] typesPtr = listVideoPayloadTypes(nativePtr);
 429                 if (typesPtr == null) return null;
 430
 431                 PayloadType[] codecs = new PayloadType[typesPtr.length];
 432
 433                 for (int i=0; i < codecs.length; i++) {
 434                         codecs[i] = new PayloadTypeImpl(typesPtr[i]);
 435                 }
 436
 437                 return codecs;
 438         }
 439         public synchronized PayloadType[] getAudioCodecs() {
 440                 long[] typesPtr = listAudioPayloadTypes(nativePtr);
 441                 if (typesPtr == null) return null;
 442
 443                 PayloadType[] codecs = new PayloadType[typesPtr.length];
 444
 445                 for (int i=0; i < codecs.length; i++) {
 446                         codecs[i] = new PayloadTypeImpl(typesPtr[i]);
 447                 }
 448
 449                 return codecs;
 450         }
 451         public synchronized boolean isNetworkReachable() {
 452                 return isNetworkStateReachable(nativePtr);
 453         }
 454
 455         public synchronized void enableKeepAlive(boolean enable) {
 456                 enableKeepAlive(nativePtr,enable);
 457
 458         }
 459         public synchronized boolean isKeepAliveEnabled() {
 460                 return isKeepAliveEnabled(nativePtr);
 461         }
 462         public synchronized void startEchoCalibration(Object data) throws LinphoneCoreException {
 463                 startEchoCalibration(nativePtr, data);
 464         }
 465
 466         public synchronized Transports getSignalingTransportPorts() {
 467                 Transports transports = new Transports();
 468                 transports.udp = getSignalingTransportPort(nativePtr, 0);
 469                 transports.tcp = getSignalingTransportPort(nativePtr, 1);
 470                 transports.tls = getSignalingTransportPort(nativePtr, 3);
 471                 // See C struct LCSipTransports in linphonecore.h
 472                 // Code is the index in the structure
 473                 return transports;
 474         }
 475         public synchronized void setSignalingTransportPorts(Transports transports) {
 476                 setSignalingTransportPorts(nativePtr, transports.udp, transports.tcp, transports.tls);
 477         }
 478
 479         public synchronized void enableIpv6(boolean enable) {
 480                 enableIpv6(nativePtr,enable);
 481         }
 482         public synchronized void adjustSoftwareVolume(int i) {
 483                 //deprecated, does the same as setPlaybackGain().
 484         }
 485
 486         public synchronized boolean pauseCall(LinphoneCall call) {
 487                 return 0 == pauseCall(nativePtr, ((LinphoneCallImpl) call).nativePtr);
 488         }
 489         public synchronized boolean resumeCall(LinphoneCall call) {
 490                 return 0 == resumeCall(nativePtr, ((LinphoneCallImpl) call).nativePtr);
 491         }
 492         public synchronized boolean pauseAllCalls() {
 493                 return 0 == pauseAllCalls(nativePtr);
 494         }
 495         public synchronized void setDownloadPtime(int ptime) {
 496                 setDownloadPtime(nativePtr,ptime);
 497
 498         }
 499         public synchronized void setUploadPtime(int ptime) {
 500                 setUploadPtime(nativePtr,ptime);
 501         }
 502
 503         public synchronized void setZrtpSecretsCache(String file) {
 504                 setZrtpSecretsCache(nativePtr,file);
 505         }
 506         public synchronized void enableEchoLimiter(boolean val) {
 507                 enableEchoLimiter(nativePtr,val);
 508         }
 509         public void setVideoDevice(int id) {
 510                 Log.i("Setting camera id :", id);
 511                 if (setVideoDevice(nativePtr, id) != 0) {
 512                         Log.e("Failed to set video device to id:", id);
 513                 }
 514         }
 515         public int getVideoDevice() {
 516                 return getVideoDevice(nativePtr);
 517         }
 518
 519
 520         private native void leaveConference(long nativePtr);
 521         public synchronized void leaveConference() {
 522                 leaveConference(nativePtr);
 523         }
 524
 525         private native boolean enterConference(long nativePtr);
 526         public synchronized boolean enterConference() {
 527                 return enterConference(nativePtr);
 528         }
 529
 530         private native boolean isInConference(long nativePtr);
 531         public synchronized boolean isInConference() {
 532                 return isInConference(nativePtr);
 533         }
 534
 535         private native void terminateConference(long nativePtr);
 536         public synchronized void terminateConference() {
 537                 terminateConference(nativePtr);
 538         }
 539         private native int getConferenceSize(long nativePtr);
 540         public synchronized int getConferenceSize() {
 541                 return getConferenceSize(nativePtr);
 542         }
 543         private native int getCallsNb(long nativePtr);
 544         public synchronized int getCallsNb() {
 545                 return getCallsNb(nativePtr);
 546         }
 547         private native void terminateAllCalls(long nativePtr);
 548         public synchronized void terminateAllCalls() {
 549                 terminateAllCalls(nativePtr);
 550         }
 551         private native Object getCall(long nativePtr, int position);
 552         public synchronized LinphoneCall[] getCalls() {
 553                 int size = getCallsNb(nativePtr);
 554                 LinphoneCall[] calls = new LinphoneCall[size];
 555                 for (int i=0; i < size; i++) {
 556                         calls[i]=((LinphoneCall)getCall(nativePtr, i));
 557                 }
 558                 return calls;
 559         }
 560         private native void addAllToConference(long nativePtr);
 561         public synchronized void addAllToConference() {
 562                 addAllToConference(nativePtr);
 563
 564         }
 565         private native void addToConference(long nativePtr, long nativePtrLcall);
 566         public synchronized void addToConference(LinphoneCall call) {
 567                 addToConference(nativePtr, getCallPtr(call));
 568
 569         }
 570         private native void removeFromConference(long nativePtr, long nativeCallPtr);
 571         public synchronized void removeFromConference(LinphoneCall call) {
 572                 removeFromConference(nativePtr,getCallPtr(call));
 573         }
 574
 575         private long getCallPtr(LinphoneCall call) {
 576                 return ((LinphoneCallImpl)call).nativePtr;
 577         }
 578
 579         private long getCallParamsPtr(LinphoneCallParams callParams) {
 580                 return ((LinphoneCallParamsImpl)callParams).nativePtr;
 581         }
 582
 583         private native int transferCall(long nativePtr, long callPtr, String referTo);
 584         public synchronized void transferCall(LinphoneCall call, String referTo) {
 585                 transferCall(nativePtr, getCallPtr(call), referTo);
 586         }
 587
 588         private native int transferCallToAnother(long nativePtr, long callPtr, long destPtr);
 589         public synchronized void transferCallToAnother(LinphoneCall call, LinphoneCall dest) {
 590                 transferCallToAnother(nativePtr, getCallPtr(call), getCallPtr(dest));
 591         }
 592
 593         private native Object findCallFromUri(long nativePtr, String uri);
 594         @Override
 595         public synchronized LinphoneCall findCallFromUri(String uri) {
 596                 return (LinphoneCall) findCallFromUri(nativePtr, uri);
 597         }
 598
 599         public synchronized MediaEncryption getMediaEncryption() {
 600                 return MediaEncryption.fromInt(getMediaEncryption(nativePtr));
 601         }
 602         public synchronized boolean isMediaEncryptionMandatory() {
 603                 return isMediaEncryptionMandatory(nativePtr);
 604         }
 605         public synchronized void setMediaEncryption(MediaEncryption menc) {
 606                 setMediaEncryption(nativePtr, menc.mValue);
 607         }
 608         public synchronized void setMediaEncryptionMandatory(boolean yesno) {
 609                 setMediaEncryptionMandatory(nativePtr, yesno);
 610         }
 611
 612         private native int getMaxCalls(long nativePtr);
 613         public synchronized int getMaxCalls() {
 614                 return getMaxCalls(nativePtr);
 615         }
 616         @Override
 617         public boolean isMyself(String uri) {
 618                 LinphoneProxyConfig lpc = getDefaultProxyConfig();
 619                 if (lpc == null) return false;
 620                 return uri.equals(lpc.getIdentity());
 621         }
 622
 623         private native boolean soundResourcesLocked(long nativePtr);
 624         public synchronized boolean soundResourcesLocked() {
 625                 return soundResourcesLocked(nativePtr);
 626         }
 627
 628         private native void setMaxCalls(long nativePtr, int max);
 629         @Override
 630         public synchronized void setMaxCalls(int max) {
 631                 setMaxCalls(nativePtr, max);
 632         }
 633         private native boolean isEchoLimiterEnabled(long nativePtr);
 634         @Override
 635         public synchronized boolean isEchoLimiterEnabled() {
 636                 return isEchoLimiterEnabled(nativePtr);
 637         }
 638         private native boolean mediaEncryptionSupported(long nativePtr, int menc);
 639         @Override
 640         public synchronized boolean mediaEncryptionSupported(MediaEncryption menc) {
 641                 return mediaEncryptionSupported(nativePtr,menc.mValue);
 642         }
 643
 644         private native void setPlayFile(long nativePtr, String path);
 645
 646         @Override
 647         public synchronized void setPlayFile(String path) {
 648                 setPlayFile(nativePtr, path);
 649         }
 650
 651
 652         private native void tunnelAddServerAndMirror(long nativePtr, String host, int port, int mirror, int ms);
 653         @Override
 654         public synchronized void tunnelAddServerAndMirror(String host, int port, int mirror, int ms) {
 655                 tunnelAddServerAndMirror(nativePtr, host, port, mirror, ms);
 656         }
 657
 658         private native void tunnelAutoDetect(long nativePtr);
 659         @Override
 660         public synchronized void tunnelAutoDetect() {
 661                 tunnelAutoDetect(nativePtr);
 662         }
 663
 664         private native void tunnelCleanServers(long nativePtr);
 665         @Override
 666         public synchronized void tunnelCleanServers() {
 667                 tunnelCleanServers(nativePtr);
 668         }
 669
 670         private native void tunnelEnable(long nativePtr, boolean enable);
 671         @Override
 672         public synchronized void tunnelEnable(boolean enable) {
 673                 tunnelEnable(nativePtr, enable);
 674         }
 675
 676         @Override
 677         public native boolean isTunnelAvailable();
 678
 679         private native void acceptCallWithParams(long nativePtr, long aCall,
 680                         long params);
 681         @Override
 682         public synchronized void acceptCallWithParams(LinphoneCall aCall,
 683                         LinphoneCallParams params) throws LinphoneCoreException {
 684                 acceptCallWithParams(nativePtr, getCallPtr(aCall), getCallParamsPtr(params));
 685         }
 686
 687         private native void acceptCallUpdate(long nativePtr, long aCall, long params);
 688         @Override
 689         public synchronized void acceptCallUpdate(LinphoneCall aCall, LinphoneCallParams params)
 690                         throws LinphoneCoreException {
 691                 acceptCallUpdate(nativePtr, getCallPtr(aCall), getCallParamsPtr(params));
 692         }
 693
 694         private native void deferCallUpdate(long nativePtr, long aCall);
 695         @Override
 696         public synchronized void deferCallUpdate(LinphoneCall aCall)
 697                         throws LinphoneCoreException {
 698                 deferCallUpdate(nativePtr, getCallPtr(aCall));
 699         }
 700
 701         private native void setVideoPolicy(long nativePtr, boolean autoInitiate, boolean autoAccept);
 702         public synchronized void setVideoPolicy(boolean autoInitiate, boolean autoAccept) {
 703                 setVideoPolicy(nativePtr, autoInitiate, autoAccept);
 704         }
 705         private native void setUserAgent(long nativePtr, String name, String version);
 706         @Override
 707         public void setUserAgent(String name, String version) {
 708                 setUserAgent(nativePtr,name,version);
 709         }
 710
 711         private native void setCpuCountNative(int count);
 712         public void setCpuCount(int count)
 713         {
 714                 setCpuCountNative(count);
 715         }
 716
 717         public int getMissedCallsCount() {
 718                 return getMissedCallsCount(nativePtr);
 719         }
 720
 721         public void removeCallLog(LinphoneCallLog log) {
 722                 removeCallLog(nativePtr, ((LinphoneCallLogImpl) log).getNativePtr());
 723         }
 724
 725         public void resetMissedCallsCount() {
 726                 resetMissedCallsCount(nativePtr);
 727         }
 728
 729         private native void tunnelSetHttpProxy(long nativePtr, String proxy_host, int port,
 730                         String username, String password);
 731         @Override
 732         public void tunnelSetHttpProxy(String proxy_host, int port,
 733                         String username, String password) {
 734                 tunnelSetHttpProxy(nativePtr, proxy_host, port, username, password);
 735         }
 736
 737         private native void refreshRegisters(long nativePtr);
 738         public void refreshRegisters() {
 739                 refreshRegisters(nativePtr);
 740         }
 741
 742         @Override
 743         public String getVersion() {
 744                 return getVersion(nativePtr);
 745         }
 746
 747         @Override
 748         public PayloadType findPayloadType(String mime, int clockRate) {
 749                 return findPayloadType(mime, clockRate, 1);
 750         }
 751
 752         private native void removeFriend(long ptr, long lf);
 753         @Override
 754         public void removeFriend(LinphoneFriend lf) {
 755                 removeFriend(nativePtr, lf.getNativePtr());
 756         }
 757
 758         private native long getFriendByAddress(long ptr, String sipUri);
 759         @Override
 760         public LinphoneFriend findFriendByAddress(String sipUri) {
 761                 long ptr = getFriendByAddress(nativePtr, sipUri);
 762                 if (ptr == 0) {
 763                         return null;
 764                 }
 765                 return new LinphoneFriendImpl(ptr);
 766         }
 767
 768         public void setAudioPort(int port) {
 769                 setAudioPort(nativePtr, port);
 770         }
 771
 772         public void setVideoPort(int port) {
 773                 setVideoPort(nativePtr, port);
 774         }
 775
 776         public void setAudioPortRange(int minPort, int maxPort) {
 777                 setAudioPortRange(nativePtr, minPort, maxPort);
 778         }
 779
 780         public void setVideoPortRange(int minPort, int maxPort) {
 781                 setVideoPortRange(nativePtr, minPort, maxPort);
 782         }
 783
 784         public void setIncomingTimeout(int timeout) {
 785                 setIncomingTimeout(nativePtr, timeout);
 786         }
 787
 788         public void setInCallTimeout(int timeout)
 789         {
 790                 setInCallTimeout(nativePtr, timeout);
 791         }
 792
 793         private native void setMicrophoneGain(long ptr, float gain);
 794         public void setMicrophoneGain(float gain) {
 795                 setMicrophoneGain(nativePtr, gain);
 796         }
 797
 798         public void setPrimaryContact(String displayName, String username) {
 799                 setPrimaryContact(nativePtr, displayName, username);
 800         }
 801
 802         private native void setUseSipInfoForDtmfs(long ptr, boolean use);
 803         public void setUseSipInfoForDtmfs(boolean use) {
 804                 setUseSipInfoForDtmfs(nativePtr, use);
 805         }
 806
 807         private native void setUseRfc2833ForDtmfs(long ptr, boolean use);
 808         public void setUseRfc2833ForDtmfs(boolean use) {
 809                 setUseRfc2833ForDtmfs(nativePtr, use);
 810         }
 811 }