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