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

   1 /*
   2 LinphoneCoreImpl.java
   3 Copyright (C) 2010  Belledonne Communications, Grenoble, France
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19 package org.linphone.core;
  20
  21 import static android.media.AudioManager.MODE_IN_CALL;
  22 import static android.media.AudioManager.MODE_RINGTONE;
  23
  24 import java.io.File;
  25 import java.io.IOException;
  26
  27 import org.linphone.core.LinphoneCall.State;
  28 import org.linphone.mediastream.Log;
  29 import org.linphone.mediastream.video.capture.hwconf.Hacks;
  30
  31 import android.content.Context;
  32 import android.media.AudioManager;
  33
  34
  35 class LinphoneCoreImpl implements LinphoneCore {
  36
  37         private final  LinphoneCoreListener mListener; //to make sure to keep a reference on this object
  38         private long nativePtr = 0;
  39         private Context mContext = null;
  40         private AudioManager mAudioManager = null;
  41         private boolean mSpeakerEnabled = false;
  42         private native long newLinphoneCore(LinphoneCoreListener listener,String userConfig,String factoryConfig,Object  userdata);
  43         private native void iterate(long nativePtr);
  44         private native long getDefaultProxyConfig(long nativePtr);
  45
  46         private native void setDefaultProxyConfig(long nativePtr,long proxyCfgNativePtr);
  47         private native int addProxyConfig(LinphoneProxyConfig jprtoxyCfg,long nativePtr,long proxyCfgNativePtr);
  48         private native void clearAuthInfos(long nativePtr);
  49
  50         private native void clearProxyConfigs(long nativePtr);
  51         private native void addAuthInfo(long nativePtr,long authInfoNativePtr);
  52         private native Object invite(long nativePtr,String uri);
  53         private native void terminateCall(long nativePtr, long call);
  54         private native long getRemoteAddress(long nativePtr);
  55         private native boolean  isInCall(long nativePtr);
  56         private native boolean isInComingInvitePending(long nativePtr);
  57         private native void acceptCall(long nativePtr, long call);
  58         private native long getCallLog(long nativePtr,int position);
  59         private native int getNumberOfCallLogs(long nativePtr);
  60         private native void delete(long nativePtr);
  61         private native void setNetworkStateReachable(long nativePtr,boolean isReachable);
  62         private native boolean isNetworkStateReachable(long nativePtr);
  63         private native void setPlaybackGain(long nativeptr, float gain);
  64         private native float getPlaybackGain(long nativeptr);
  65         private native void muteMic(long nativePtr,boolean isMuted);
  66         private native long interpretUrl(long nativePtr,String destination);
  67         private native Object inviteAddress(long nativePtr,long to);
  68         private native Object inviteAddressWithParams(long nativePtrLc,long to, long nativePtrParam);
  69         private native void sendDtmf(long nativePtr,char dtmf);
  70         private native void clearCallLogs(long nativePtr);
  71         private native boolean isMicMuted(long nativePtr);
  72         private native long findPayloadType(long nativePtr, String mime, int clockRate, int channels);
  73         private native int enablePayloadType(long nativePtr, long payloadType,  boolean enable);
  74         private native void enableEchoCancellation(long nativePtr,boolean enable);
  75         private native boolean isEchoCancellationEnabled(long nativePtr);
  76         private native Object getCurrentCall(long nativePtr) ;
  77         private native void playDtmf(long nativePtr,char dtmf,int duration);
  78         private native void stopDtmf(long nativePtr);
  79         private native void setVideoWindowId(long nativePtr, Object wid);
  80         private native void setPreviewWindowId(long nativePtr, Object wid);
  81         private native void setDeviceRotation(long nativePtr, int rotation);
  82         private native void addFriend(long nativePtr,long friend);
  83         private native void setPresenceInfo(long nativePtr,int minute_away, String alternative_contact,int status);
  84         private native long createChatRoom(long nativePtr,String to);
  85         private native void enableVideo(long nativePtr,boolean vcap_enabled,boolean display_enabled);
  86         private native boolean isVideoEnabled(long nativePtr);
  87         private native void setFirewallPolicy(long nativePtr, int enum_value);
  88         private native int getFirewallPolicy(long nativePtr);
  89         private native void setStunServer(long nativePtr, String stun_server);
  90         private native String getStunServer(long nativePtr);
  91         private native long createDefaultCallParams(long nativePtr);
  92         private native int updateCall(long ptrLc, long ptrCall, long ptrParams);
  93         private native void setUploadBandwidth(long nativePtr, int bw);
  94         private native void setDownloadBandwidth(long nativePtr, int bw);
  95         private native void setPreferredVideoSize(long nativePtr, int width, int heigth);
  96         private native int[] getPreferredVideoSize(long nativePtr);
  97         private native void setRing(long nativePtr, String path);
  98         private native String getRing(long nativePtr);
  99         private native void setRootCA(long nativePtr, String path);
 100         private native long[] listVideoPayloadTypes(long nativePtr);
 101         private native long[] getProxyConfigList(long nativePtr);
 102         private native long[] listAudioPayloadTypes(long nativePtr);
 103         private native void enableKeepAlive(long nativePtr,boolean enable);
 104         private native boolean isKeepAliveEnabled(long nativePtr);
 105         private native int startEchoCalibration(long nativePtr,Object data);
 106         private native int getSignalingTransportPort(long nativePtr, int code);
 107         private native void setSignalingTransportPorts(long nativePtr, int udp, int tcp, int tls);
 108         private native void enableIpv6(long nativePtr,boolean enable);
 109         private native int pauseCall(long nativePtr, long callPtr);
 110         private native int pauseAllCalls(long nativePtr);
 111         private native int resumeCall(long nativePtr, long callPtr);
 112         private native void setUploadPtime(long nativePtr, int ptime);
 113         private native void setDownloadPtime(long nativePtr, int ptime);
 114         private native void setZrtpSecretsCache(long nativePtr, String file);
 115         private native void enableEchoLimiter(long nativePtr2, boolean val);
 116         private native int setVideoDevice(long nativePtr2, int id);
 117         private native int getVideoDevice(long nativePtr2);
 118         private native int getMediaEncryption(long nativePtr);
 119         private native void setMediaEncryption(long nativePtr, int menc);
 120         private native boolean isMediaEncryptionMandatory(long nativePtr);
 121         private native void setMediaEncryptionMandatory(long nativePtr, boolean yesno);
 122         private native void removeCallLog(long nativePtr, long callLogPtr);
 123         private native int getMissedCallsCount(long nativePtr);
 124         private native void resetMissedCallsCount(long nativePtr);
 125         private native String getVersion(long nativePtr);
 126         private native void setAudioPort(long nativePtr, int port);
 127         private native void setVideoPort(long nativePtr, int port);
 128         private native void setAudioPortRange(long nativePtr, int minPort, int maxPort);
 129         private native void setVideoPortRange(long nativePtr, int minPort, int maxPort);
 130         private native void setIncomingTimeout(long nativePtr, int timeout);
 131         private native void setInCallTimeout(long nativePtr, int timeout);
 132         private native void setPrimaryContact(long nativePtr, String displayName, String username);
 133
 134         LinphoneCoreImpl(LinphoneCoreListener listener, File userConfig,File factoryConfig,Object  userdata) throws IOException {
 135                 mListener=listener;
 136                 nativePtr = newLinphoneCore(listener,userConfig.getCanonicalPath(),factoryConfig.getCanonicalPath(),userdata);
 137         }
 138         LinphoneCoreImpl(LinphoneCoreListener listener) throws IOException {
 139                 mListener=listener;
 140                 nativePtr = newLinphoneCore(listener,null,null,null);
 141         }
 142
 143         protected void finalize() throws Throwable {
 144
 145         }
 146
 147         private boolean contextInitialized() {
 148                 if (mContext == null) {
 149                         Log.e("Context of LinphoneCore has not been initialized, call setContext() after creating LinphoneCore.");
 150                         return false;
 151                 }
 152                 return true;
 153         }
 154         public void setContext(Object context) {
 155                 mContext = (Context)context;
 156                 mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
 157         }
 158
 159         public synchronized void addAuthInfo(LinphoneAuthInfo info) {
 160                 isValid();
 161                 addAuthInfo(nativePtr,((LinphoneAuthInfoImpl)info).nativePtr);
 162         }
 163
 164         public synchronized LinphoneProxyConfig getDefaultProxyConfig() {
 165                 isValid();
 166                 long lNativePtr = getDefaultProxyConfig(nativePtr);
 167                 if (lNativePtr!=0) {
 168                         return new LinphoneProxyConfigImpl(lNativePtr);
 169                 } else {
 170                         return null;
 171                 }
 172         }
 173
 174         public synchronized LinphoneCall invite(String uri) {
 175                 isValid();
 176                 return (LinphoneCall)invite(nativePtr,uri);
 177         }
 178
 179         public synchronized void iterate() {
 180                 isValid();
 181                 iterate(nativePtr);
 182         }
 183
 184         public synchronized void setDefaultProxyConfig(LinphoneProxyConfig proxyCfg) {
 185                 isValid();
 186                 setDefaultProxyConfig(nativePtr,((LinphoneProxyConfigImpl)proxyCfg).nativePtr);
 187         }
 188         public synchronized void addProxyConfig(LinphoneProxyConfig proxyCfg) throws LinphoneCoreException{
 189                 isValid();
 190                 if (addProxyConfig(proxyCfg,nativePtr,((LinphoneProxyConfigImpl)proxyCfg).nativePtr) !=0) {
 191                         throw new LinphoneCoreException("bad proxy config");
 192                 }
 193         }
 194         public synchronized void clearAuthInfos() {
 195                 isValid();
 196                 clearAuthInfos(nativePtr);
 197
 198         }
 199         public synchronized void clearProxyConfigs() {
 200                 isValid();
 201                 clearProxyConfigs(nativePtr);
 202         }
 203         public synchronized void terminateCall(LinphoneCall aCall) {
 204                 isValid();
 205                 if (aCall!=null)terminateCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr);
 206         }
 207         public synchronized LinphoneAddress getRemoteAddress() {
 208                 isValid();
 209                 long ptr = getRemoteAddress(nativePtr);
 210                 if (ptr==0) {
 211                         return null;
 212                 } else {
 213                         return new LinphoneAddressImpl(ptr);
 214                 }
 215         }
 216         public synchronized  boolean isIncall() {
 217                 isValid();
 218                 return isInCall(nativePtr);
 219         }
 220         public synchronized boolean isInComingInvitePending() {
 221                 isValid();
 222                 return isInComingInvitePending(nativePtr);
 223         }
 224         public synchronized void acceptCall(LinphoneCall aCall) {
 225                 isValid();
 226                 acceptCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr);
 227         }
 228         public synchronized LinphoneCallLog[] getCallLogs() {
 229                 isValid();
 230                 LinphoneCallLog[] logs = new LinphoneCallLog[getNumberOfCallLogs(nativePtr)];
 231                 for (int i=0;i < getNumberOfCallLogs(nativePtr);i++) {
 232                         logs[i] = new LinphoneCallLogImpl(getCallLog(nativePtr, i));
 233                 }
 234                 return logs;
 235         }
 236         public synchronized void destroy() {
 237                 isValid();
 238                 delete(nativePtr);
 239                 nativePtr = 0;
 240         }
 241
 242         private void isValid() {
 243                 if (nativePtr == 0) {
 244                         throw new RuntimeException("object already destroyed");
 245                 }
 246         }
 247         public synchronized void setNetworkReachable(boolean isReachable) {
 248                 setNetworkStateReachable(nativePtr,isReachable);
 249         }
 250         public synchronized void setPlaybackGain(float gain) {
 251                 setPlaybackGain(nativePtr,gain);
 252
 253         }
 254         public synchronized float getPlaybackGain() {
 255                 return getPlaybackGain(nativePtr);
 256         }
 257         public synchronized void muteMic(boolean isMuted) {
 258                 muteMic(nativePtr,isMuted);
 259         }
 260
 261         public synchronized LinphoneAddress interpretUrl(String destination) throws LinphoneCoreException {
 262                 long lAddress = interpretUrl(nativePtr,destination);
 263                 if (lAddress != 0) {
 264                         return new LinphoneAddressImpl(lAddress,true);
 265                 } else {
 266                         throw new LinphoneCoreException("Cannot interpret ["+destination+"]");
 267                 }
 268         }
 269         public synchronized LinphoneCall invite(LinphoneAddress to) throws LinphoneCoreException {
 270                 LinphoneCall call = (LinphoneCall)inviteAddress(nativePtr,((LinphoneAddressImpl)to).nativePtr);
 271                 if (call!=null) {
 272                         return call;
 273                 } else {
 274                         throw new LinphoneCoreException("Unable to invite address " + to.asString());
 275                 }
 276         }
 277
 278         public synchronized void sendDtmf(char number) {
 279                 sendDtmf(nativePtr,number);
 280         }
 281         public synchronized void clearCallLogs() {
 282                 clearCallLogs(nativePtr);
 283         }
 284         public synchronized boolean isMicMuted() {
 285                 return isMicMuted(nativePtr);
 286         }
 287         public synchronized PayloadType findPayloadType(String mime, int clockRate, int channels) {
 288                 isValid();
 289                 long playLoadType = findPayloadType(nativePtr, mime, clockRate, channels);
 290                 if (playLoadType == 0) {
 291                         return null;
 292                 } else {
 293                         return new PayloadTypeImpl(playLoadType);
 294                 }
 295         }
 296         public synchronized void enablePayloadType(PayloadType pt, boolean enable)
 297                         throws LinphoneCoreException {
 298                 isValid();
 299                 if (enablePayloadType(nativePtr,((PayloadTypeImpl)pt).nativePtr,enable) != 0) {
 300                         throw new LinphoneCoreException("cannot enable payload type ["+pt+"]");
 301                 }
 302
 303         }
 304         public synchronized void enableEchoCancellation(boolean enable) {
 305                 isValid();
 306                 enableEchoCancellation(nativePtr, enable);
 307         }
 308         public synchronized boolean isEchoCancellationEnabled() {
 309                 isValid();
 310                 return isEchoCancellationEnabled(nativePtr);
 311
 312         }
 313
 314         public synchronized LinphoneCall getCurrentCall() {
 315                 isValid();
 316                 return (LinphoneCall)getCurrentCall(nativePtr);
 317         }
 318
 319         public int getPlayLevel() {
 320                 // TODO Auto-generated method stub
 321                 return 0;
 322         }
 323         public void setPlayLevel(int level) {
 324                 // TODO Auto-generated method stub
 325
 326         }
 327
 328         private void applyAudioHacks() {
 329                 if (Hacks.needGalaxySAudioHack()) {
 330                         /* The microphone gain is way too high on the Galaxy S so correct it here. */
 331                         setMicrophoneGain(-9.0f);
 332                 }
 333         }
 334         private void setAudioModeIncallForGalaxyS() {
 335                 if (!contextInitialized()) return;
 336                 mAudioManager.setMode(MODE_IN_CALL);
 337         }
 338         public void routeAudioToSpeakerHelper(boolean speakerOn) {
 339                 if (!contextInitialized()) return;
 340                 if (Hacks.needGalaxySAudioHack())
 341                         setAudioModeIncallForGalaxyS();
 342                 mAudioManager.setSpeakerphoneOn(speakerOn);
 343         }
 344         private native void forceSpeakerState(long nativePtr, boolean speakerOn);
 345         public void enableSpeaker(boolean value) {
 346                 final LinphoneCall call = getCurrentCall();
 347                 mSpeakerEnabled = value;
 348                 applyAudioHacks();
 349                 if (call != null && call.getState() == State.StreamsRunning && Hacks.needGalaxySAudioHack()) {
 350                         Log.d("Hack to have speaker=", value, " while on call");
 351                         forceSpeakerState(nativePtr, value);
 352                 } else {
 353                         routeAudioToSpeakerHelper(value);
 354                 }
 355         }
 356         public boolean isSpeakerEnabled() {
 357                 return mSpeakerEnabled;
 358         }
 359         public synchronized void playDtmf(char number, int duration) {
 360                 playDtmf(nativePtr,number, duration);
 361
 362         }
 363         public synchronized void stopDtmf() {
 364                 stopDtmf(nativePtr);
 365         }
 366
 367         public synchronized void addFriend(LinphoneFriend lf) throws LinphoneCoreException {
 368                 addFriend(nativePtr,((LinphoneFriendImpl)lf).nativePtr);
 369
 370         }
 371         public synchronized void setPresenceInfo(int minute_away, String alternative_contact,
 372                         OnlineStatus status) {
 373                 setPresenceInfo(nativePtr,minute_away,alternative_contact,status.mValue);
 374
 375         }
 376         public synchronized LinphoneChatRoom createChatRoom(String to) {
 377                 return new LinphoneChatRoomImpl(createChatRoom(nativePtr,to));
 378         }
 379         public synchronized void setPreviewWindow(Object w) {
 380                 setPreviewWindowId(nativePtr,w);
 381         }
 382         public synchronized void setVideoWindow(Object w) {
 383                 setVideoWindowId(nativePtr, w);
 384         }
 385         public synchronized void setDeviceRotation(int rotation) {
 386                 setDeviceRotation(nativePtr, rotation);
 387         }
 388
 389         public synchronized void enableVideo(boolean vcap_enabled, boolean display_enabled) {
 390                 enableVideo(nativePtr,vcap_enabled, display_enabled);
 391         }
 392         public synchronized boolean isVideoEnabled() {
 393                 return isVideoEnabled(nativePtr);
 394         }
 395         public synchronized FirewallPolicy getFirewallPolicy() {
 396                 return FirewallPolicy.fromInt(getFirewallPolicy(nativePtr));
 397         }
 398         public synchronized String getStunServer() {
 399                 return getStunServer(nativePtr);
 400         }
 401         public synchronized void setFirewallPolicy(FirewallPolicy pol) {
 402                 setFirewallPolicy(nativePtr,pol.value());
 403         }
 404         public synchronized void setStunServer(String stunServer) {
 405                 setStunServer(nativePtr,stunServer);
 406         }
 407
 408         public synchronized LinphoneCallParams createDefaultCallParameters() {
 409                 return new LinphoneCallParamsImpl(createDefaultCallParams(nativePtr));
 410         }
 411
 412         public synchronized LinphoneCall inviteAddressWithParams(LinphoneAddress to, LinphoneCallParams params) throws LinphoneCoreException {
 413                 long ptrDestination = ((LinphoneAddressImpl)to).nativePtr;
 414                 long ptrParams =((LinphoneCallParamsImpl)params).nativePtr;
 415
 416                 LinphoneCall call = (LinphoneCall)inviteAddressWithParams(nativePtr, ptrDestination, ptrParams);
 417                 if (call!=null) {
 418                         return call;
 419                 } else {
 420                         throw new LinphoneCoreException("Unable to invite with params " + to.asString());
 421                 }
 422         }
 423
 424         public synchronized int updateCall(LinphoneCall call, LinphoneCallParams params) {
 425                 long ptrCall = ((LinphoneCallImpl) call).nativePtr;
 426                 long ptrParams = params!=null ? ((LinphoneCallParamsImpl)params).nativePtr : 0;
 427
 428                 return updateCall(nativePtr, ptrCall, ptrParams);
 429         }
 430         public synchronized void setUploadBandwidth(int bw) {
 431                 setUploadBandwidth(nativePtr, bw);
 432         }
 433
 434         public synchronized void setDownloadBandwidth(int bw) {
 435                 setDownloadBandwidth(nativePtr, bw);
 436         }
 437
 438         public synchronized void setPreferredVideoSize(VideoSize vSize) {
 439                 setPreferredVideoSize(nativePtr, vSize.width, vSize.height);
 440         }
 441
 442         public synchronized VideoSize getPreferredVideoSize() {
 443                 int[] nativeSize = getPreferredVideoSize(nativePtr);
 444
 445                 VideoSize vSize = new VideoSize();
 446                 vSize.width = nativeSize[0];
 447                 vSize.height = nativeSize[1];
 448                 return vSize;
 449         }
 450         public synchronized void setRing(String path) {
 451                 setRing(nativePtr, path);
 452         }
 453         public synchronized String getRing() {
 454                 return getRing(nativePtr);
 455         }
 456
 457         public synchronized void setRootCA(String path) {
 458                 setRootCA(nativePtr, path);
 459         }
 460
 461         public synchronized LinphoneProxyConfig[] getProxyConfigList() {
 462                 long[] typesPtr = getProxyConfigList(nativePtr);
 463                 if (typesPtr == null) return null;
 464
 465                 LinphoneProxyConfig[] proxies = new LinphoneProxyConfig[typesPtr.length];
 466
 467                 for (int i=0; i < proxies.length; i++) {
 468                         proxies[i] = new LinphoneProxyConfigImpl(typesPtr[i]);
 469                 }
 470
 471                 return proxies;
 472         }
 473
 474         public synchronized PayloadType[] getVideoCodecs() {
 475                 long[] typesPtr = listVideoPayloadTypes(nativePtr);
 476                 if (typesPtr == null) return null;
 477
 478                 PayloadType[] codecs = new PayloadType[typesPtr.length];
 479
 480                 for (int i=0; i < codecs.length; i++) {
 481                         codecs[i] = new PayloadTypeImpl(typesPtr[i]);
 482                 }
 483
 484                 return codecs;
 485         }
 486         public synchronized PayloadType[] getAudioCodecs() {
 487                 long[] typesPtr = listAudioPayloadTypes(nativePtr);
 488                 if (typesPtr == null) return null;
 489
 490                 PayloadType[] codecs = new PayloadType[typesPtr.length];
 491
 492                 for (int i=0; i < codecs.length; i++) {
 493                         codecs[i] = new PayloadTypeImpl(typesPtr[i]);
 494                 }
 495
 496                 return codecs;
 497         }
 498         public synchronized boolean isNetworkReachable() {
 499                 return isNetworkStateReachable(nativePtr);
 500         }
 501
 502         public synchronized void enableKeepAlive(boolean enable) {
 503                 enableKeepAlive(nativePtr,enable);
 504
 505         }
 506         public synchronized boolean isKeepAliveEnabled() {
 507                 return isKeepAliveEnabled(nativePtr);
 508         }
 509         public synchronized void startEchoCalibration(Object data) throws LinphoneCoreException {
 510                 startEchoCalibration(nativePtr, data);
 511         }
 512
 513         public synchronized Transports getSignalingTransportPorts() {
 514                 Transports transports = new Transports();
 515                 transports.udp = getSignalingTransportPort(nativePtr, 0);
 516                 transports.tcp = getSignalingTransportPort(nativePtr, 1);
 517                 transports.tls = getSignalingTransportPort(nativePtr, 3);
 518                 // See C struct LCSipTransports in linphonecore.h
 519                 // Code is the index in the structure
 520                 return transports;
 521         }
 522         public synchronized void setSignalingTransportPorts(Transports transports) {
 523                 setSignalingTransportPorts(nativePtr, transports.udp, transports.tcp, transports.tls);
 524         }
 525
 526         public synchronized void enableIpv6(boolean enable) {
 527                 enableIpv6(nativePtr,enable);
 528         }
 529         public synchronized void adjustSoftwareVolume(int i) {
 530                 //deprecated, does the same as setPlaybackGain().
 531         }
 532
 533         public synchronized boolean pauseCall(LinphoneCall call) {
 534                 return 0 == pauseCall(nativePtr, ((LinphoneCallImpl) call).nativePtr);
 535         }
 536         public synchronized boolean resumeCall(LinphoneCall call) {
 537                 return 0 == resumeCall(nativePtr, ((LinphoneCallImpl) call).nativePtr);
 538         }
 539         public synchronized boolean pauseAllCalls() {
 540                 return 0 == pauseAllCalls(nativePtr);
 541         }
 542         public synchronized void setDownloadPtime(int ptime) {
 543                 setDownloadPtime(nativePtr,ptime);
 544
 545         }
 546         public synchronized void setUploadPtime(int ptime) {
 547                 setUploadPtime(nativePtr,ptime);
 548         }
 549
 550         public synchronized void setZrtpSecretsCache(String file) {
 551                 setZrtpSecretsCache(nativePtr,file);
 552         }
 553         public synchronized void enableEchoLimiter(boolean val) {
 554                 enableEchoLimiter(nativePtr,val);
 555         }
 556         public void setVideoDevice(int id) {
 557                 Log.i("Setting camera id :", id);
 558                 if (setVideoDevice(nativePtr, id) != 0) {
 559                         Log.e("Failed to set video device to id:", id);
 560                 }
 561         }
 562         public int getVideoDevice() {
 563                 return getVideoDevice(nativePtr);
 564         }
 565
 566
 567         private native void leaveConference(long nativePtr);
 568         public synchronized void leaveConference() {
 569                 leaveConference(nativePtr);
 570         }
 571
 572         private native boolean enterConference(long nativePtr);
 573         public synchronized boolean enterConference() {
 574                 return enterConference(nativePtr);
 575         }
 576
 577         private native boolean isInConference(long nativePtr);
 578         public synchronized boolean isInConference() {
 579                 return isInConference(nativePtr);
 580         }
 581
 582         private native void terminateConference(long nativePtr);
 583         public synchronized void terminateConference() {
 584                 terminateConference(nativePtr);
 585         }
 586         private native int getConferenceSize(long nativePtr);
 587         public synchronized int getConferenceSize() {
 588                 return getConferenceSize(nativePtr);
 589         }
 590         private native int getCallsNb(long nativePtr);
 591         public synchronized int getCallsNb() {
 592                 return getCallsNb(nativePtr);
 593         }
 594         private native void terminateAllCalls(long nativePtr);
 595         public synchronized void terminateAllCalls() {
 596                 terminateAllCalls(nativePtr);
 597         }
 598         private native Object getCall(long nativePtr, int position);
 599         public synchronized LinphoneCall[] getCalls() {
 600                 int size = getCallsNb(nativePtr);
 601                 LinphoneCall[] calls = new LinphoneCall[size];
 602                 for (int i=0; i < size; i++) {
 603                         calls[i]=((LinphoneCall)getCall(nativePtr, i));
 604                 }
 605                 return calls;
 606         }
 607         private native void addAllToConference(long nativePtr);
 608         public synchronized void addAllToConference() {
 609                 addAllToConference(nativePtr);
 610
 611         }
 612         private native void addToConference(long nativePtr, long nativePtrLcall);
 613         public synchronized void addToConference(LinphoneCall call) {
 614                 addToConference(nativePtr, getCallPtr(call));
 615
 616         }
 617         private native void removeFromConference(long nativePtr, long nativeCallPtr);
 618         public synchronized void removeFromConference(LinphoneCall call) {
 619                 removeFromConference(nativePtr,getCallPtr(call));
 620         }
 621
 622         private long getCallPtr(LinphoneCall call) {
 623                 return ((LinphoneCallImpl)call).nativePtr;
 624         }
 625
 626         private long getCallParamsPtr(LinphoneCallParams callParams) {
 627                 return ((LinphoneCallParamsImpl)callParams).nativePtr;
 628         }
 629
 630         private native int transferCall(long nativePtr, long callPtr, String referTo);
 631         public synchronized void transferCall(LinphoneCall call, String referTo) {
 632                 transferCall(nativePtr, getCallPtr(call), referTo);
 633         }
 634
 635         private native int transferCallToAnother(long nativePtr, long callPtr, long destPtr);
 636         public synchronized void transferCallToAnother(LinphoneCall call, LinphoneCall dest) {
 637                 transferCallToAnother(nativePtr, getCallPtr(call), getCallPtr(dest));
 638         }
 639
 640         private native Object findCallFromUri(long nativePtr, String uri);
 641         @Override
 642         public synchronized LinphoneCall findCallFromUri(String uri) {
 643                 return (LinphoneCall) findCallFromUri(nativePtr, uri);
 644         }
 645
 646         public synchronized MediaEncryption getMediaEncryption() {
 647                 return MediaEncryption.fromInt(getMediaEncryption(nativePtr));
 648         }
 649         public synchronized boolean isMediaEncryptionMandatory() {
 650                 return isMediaEncryptionMandatory(nativePtr);
 651         }
 652         public synchronized void setMediaEncryption(MediaEncryption menc) {
 653                 setMediaEncryption(nativePtr, menc.mValue);
 654         }
 655         public synchronized void setMediaEncryptionMandatory(boolean yesno) {
 656                 setMediaEncryptionMandatory(nativePtr, yesno);
 657         }
 658
 659         private native int getMaxCalls(long nativePtr);
 660         public synchronized int getMaxCalls() {
 661                 return getMaxCalls(nativePtr);
 662         }
 663         @Override
 664         public boolean isMyself(String uri) {
 665                 LinphoneProxyConfig lpc = getDefaultProxyConfig();
 666                 if (lpc == null) return false;
 667                 return uri.equals(lpc.getIdentity());
 668         }
 669
 670         private native boolean soundResourcesLocked(long nativePtr);
 671         public synchronized boolean soundResourcesLocked() {
 672                 return soundResourcesLocked(nativePtr);
 673         }
 674
 675         private native void setMaxCalls(long nativePtr, int max);
 676         @Override
 677         public synchronized void setMaxCalls(int max) {
 678                 setMaxCalls(nativePtr, max);
 679         }
 680         private native boolean isEchoLimiterEnabled(long nativePtr);
 681         @Override
 682         public synchronized boolean isEchoLimiterEnabled() {
 683                 return isEchoLimiterEnabled(nativePtr);
 684         }
 685         private native boolean mediaEncryptionSupported(long nativePtr, int menc);
 686         @Override
 687         public synchronized boolean mediaEncryptionSupported(MediaEncryption menc) {
 688                 return mediaEncryptionSupported(nativePtr,menc.mValue);
 689         }
 690
 691         private native void setPlayFile(long nativePtr, String path);
 692
 693         @Override
 694         public synchronized void setPlayFile(String path) {
 695                 setPlayFile(nativePtr, path);
 696         }
 697
 698
 699         private native void tunnelAddServerAndMirror(long nativePtr, String host, int port, int mirror, int ms);
 700         @Override
 701         public synchronized void tunnelAddServerAndMirror(String host, int port, int mirror, int ms) {
 702                 tunnelAddServerAndMirror(nativePtr, host, port, mirror, ms);
 703         }
 704
 705         private native void tunnelAutoDetect(long nativePtr);
 706         @Override
 707         public synchronized void tunnelAutoDetect() {
 708                 tunnelAutoDetect(nativePtr);
 709         }
 710
 711         private native void tunnelCleanServers(long nativePtr);
 712         @Override
 713         public synchronized void tunnelCleanServers() {
 714                 tunnelCleanServers(nativePtr);
 715         }
 716
 717         private native void tunnelEnable(long nativePtr, boolean enable);
 718         @Override
 719         public synchronized void tunnelEnable(boolean enable) {
 720                 tunnelEnable(nativePtr, enable);
 721         }
 722
 723         @Override
 724         public native boolean isTunnelAvailable();
 725
 726         private native void acceptCallWithParams(long nativePtr, long aCall,
 727                         long params);
 728         @Override
 729         public synchronized void acceptCallWithParams(LinphoneCall aCall,
 730                         LinphoneCallParams params) throws LinphoneCoreException {
 731                 acceptCallWithParams(nativePtr, getCallPtr(aCall), getCallParamsPtr(params));
 732         }
 733
 734         private native void acceptCallUpdate(long nativePtr, long aCall, long params);
 735         @Override
 736         public synchronized void acceptCallUpdate(LinphoneCall aCall, LinphoneCallParams params)
 737                         throws LinphoneCoreException {
 738                 acceptCallUpdate(nativePtr, getCallPtr(aCall), getCallParamsPtr(params));
 739         }
 740
 741         private native void deferCallUpdate(long nativePtr, long aCall);
 742         @Override
 743         public synchronized void deferCallUpdate(LinphoneCall aCall)
 744                         throws LinphoneCoreException {
 745                 deferCallUpdate(nativePtr, getCallPtr(aCall));
 746         }
 747
 748
 749         private native void setVideoPolicy(long nativePtr, boolean autoInitiate, boolean autoAccept);
 750         public synchronized void setVideoPolicy(boolean autoInitiate, boolean autoAccept) {
 751                 setVideoPolicy(nativePtr, autoInitiate, autoAccept);
 752         }
 753         private native void setStaticPicture(long nativePtr, String path);
 754         public synchronized void setStaticPicture(String path) {
 755                 setStaticPicture(nativePtr, path);
 756         }
 757         private native void setUserAgent(long nativePtr, String name, String version);
 758         @Override
 759         public synchronized void setUserAgent(String name, String version) {
 760                 setUserAgent(nativePtr,name,version);
 761         }
 762
 763         private native void setCpuCountNative(int count);
 764         public synchronized void setCpuCount(int count)
 765         {
 766                 setCpuCountNative(count);
 767         }
 768
 769         public synchronized int getMissedCallsCount() {
 770                 return getMissedCallsCount(nativePtr);
 771         }
 772
 773         public synchronized void removeCallLog(LinphoneCallLog log) {
 774                 removeCallLog(nativePtr, ((LinphoneCallLogImpl) log).getNativePtr());
 775         }
 776
 777         public synchronized void resetMissedCallsCount() {
 778                 resetMissedCallsCount(nativePtr);
 779         }
 780
 781         private native void tunnelSetHttpProxy(long nativePtr, String proxy_host, int port,
 782                         String username, String password);
 783         @Override
 784         public void tunnelSetHttpProxy(String proxy_host, int port,
 785                         String username, String password) {
 786                 tunnelSetHttpProxy(nativePtr, proxy_host, port, username, password);
 787         }
 788
 789         private native void refreshRegisters(long nativePtr);
 790         public synchronized void refreshRegisters() {
 791                 refreshRegisters(nativePtr);
 792         }
 793
 794         @Override
 795         public String getVersion() {
 796                 return getVersion(nativePtr);
 797         }
 798         /**
 799          * Wildcard value used by #linphone_core_find_payload_type to ignore rate in search algorithm
 800          */
 801         static int FIND_PAYLOAD_IGNORE_RATE = -1;
 802         /**
 803          * Wildcard value used by #linphone_core_find_payload_type to ignore channel in search algorithm
 804          */
 805         static int FIND_PAYLOAD_IGNORE_CHANNELS = -1;
 806         @Override
 807         public synchronized PayloadType findPayloadType(String mime, int clockRate) {
 808                 return findPayloadType(mime, clockRate, FIND_PAYLOAD_IGNORE_CHANNELS);
 809         }
 810
 811         private native void removeFriend(long ptr, long lf);
 812         @Override
 813         public synchronized void removeFriend(LinphoneFriend lf) {
 814                 removeFriend(nativePtr, lf.getNativePtr());
 815         }
 816
 817         private native long getFriendByAddress(long ptr, String sipUri);
 818         @Override
 819         public synchronized LinphoneFriend findFriendByAddress(String sipUri) {
 820                 long ptr = getFriendByAddress(nativePtr, sipUri);
 821                 if (ptr == 0) {
 822                         return null;
 823                 }
 824                 return new LinphoneFriendImpl(ptr);
 825         }
 826
 827         public synchronized void setAudioPort(int port) {
 828                 setAudioPort(nativePtr, port);
 829         }
 830
 831         public synchronized void setVideoPort(int port) {
 832                 setVideoPort(nativePtr, port);
 833         }
 834
 835         public synchronized void setAudioPortRange(int minPort, int maxPort) {
 836                 setAudioPortRange(nativePtr, minPort, maxPort);
 837         }
 838
 839         public synchronized void setVideoPortRange(int minPort, int maxPort) {
 840                 setVideoPortRange(nativePtr, minPort, maxPort);
 841         }
 842
 843         public synchronized void setIncomingTimeout(int timeout) {
 844                 setIncomingTimeout(nativePtr, timeout);
 845         }
 846
 847         public synchronized void setInCallTimeout(int timeout)
 848         {
 849                 setInCallTimeout(nativePtr, timeout);
 850         }
 851
 852         private native void setMicrophoneGain(long ptr, float gain);
 853         public synchronized void setMicrophoneGain(float gain) {
 854                 setMicrophoneGain(nativePtr, gain);
 855         }
 856
 857         public synchronized void setPrimaryContact(String displayName, String username) {
 858                 setPrimaryContact(nativePtr, displayName, username);
 859         }
 860
 861         private native void setUseSipInfoForDtmfs(long ptr, boolean use);
 862         public synchronized void setUseSipInfoForDtmfs(boolean use) {
 863                 setUseSipInfoForDtmfs(nativePtr, use);
 864         }
 865
 866         private native void setUseRfc2833ForDtmfs(long ptr, boolean use);
 867         public synchronized void setUseRfc2833ForDtmfs(boolean use) {
 868                 setUseRfc2833ForDtmfs(nativePtr, use);
 869         }
 870
 871         private native long getConfig(long ptr);
 872         public synchronized LpConfig getConfig() {
 873                 long configPtr=getConfig(nativePtr);
 874                 return new LpConfigImpl(configPtr);
 875         }
 876         private native boolean needsEchoCalibration(long ptr);
 877         @Override
 878         public synchronized boolean needsEchoCalibration() {
 879                 return needsEchoCalibration(nativePtr);
 880         }
 881         private native void declineCall(long coreptr, long callptr, int reason);
 882         @Override
 883         public synchronized void declineCall(LinphoneCall aCall, Reason reason) {
 884                 declineCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr,reason.mValue);
 885         }
 886
 887         private native boolean upnpAvailable(long ptr);
 888         public boolean upnpAvailable() {
 889                 return upnpAvailable(nativePtr);
 890         }
 891
 892         private native int getUpnpState(long ptr);
 893         public UpnpState getUpnpState() {
 894                 return UpnpState.fromInt(getUpnpState(nativePtr));
 895         }
 896
 897         private native String getUpnpExternalIpaddress(long ptr);
 898         public String getUpnpExternalIpaddress() {
 899                 return getUpnpExternalIpaddress(nativePtr);
 900         }
 901         private native int startConferenceRecording(long nativePtr, String path);
 902         @Override
 903         public void startConferenceRecording(String path) {
 904                 startConferenceRecording(nativePtr,path);
 905         }
 906
 907         private native int stopConferenceRecording(long nativePtr);
 908         @Override
 909         public void stopConferenceRecording() {
 910                 stopConferenceRecording(nativePtr);
 911         }
 912         @Override
 913         public PayloadType findPayloadType(String mime) {
 914                 return findPayloadType(mime, FIND_PAYLOAD_IGNORE_RATE);
 915         }
 916
 917         private native void setSipDscp(long nativePtr, int dscp);
 918         @Override
 919         public void setSipDscp(int dscp) {
 920                 setSipDscp(nativePtr,dscp);
 921         }
 922
 923         private native int getSipDscp(long nativePtr);
 924         @Override
 925         public int getSipDscp() {
 926                 return getSipDscp(nativePtr);
 927         }
 928         private native void setAudioDscp(long nativePtr, int dscp);
 929         @Override
 930         public void setAudioDscp(int dscp) {
 931                 setAudioDscp(nativePtr, dscp);
 932         }
 933
 934         private native int getAudioDscp(long nativePtr);
 935         @Override
 936         public int getAudioDscp() {
 937                 return getAudioDscp(nativePtr);
 938         }
 939
 940         private native void setVideoDscp(long nativePtr, int dscp);
 941         @Override
 942         public void setVideoDscp(int dscp) {
 943                 setVideoDscp(nativePtr,dscp);
 944         }
 945
 946         private native int getVideoDscp(long nativePtr);
 947         @Override
 948         public int getVideoDscp() {
 949                 return getVideoDscp(nativePtr);
 950         }
 951 }