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