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