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