3 Copyright (C) 2010 Belledonne Communications, Grenoble, France
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.
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.
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.
19 package org.linphone.core;
21 import static android.media.AudioManager.MODE_IN_CALL;
22 import static android.media.AudioManager.MODE_RINGTONE;
25 import java.io.IOException;
27 import org.linphone.core.LinphoneCall.State;
28 import org.linphone.mediastream.Log;
29 import org.linphone.mediastream.video.capture.hwconf.Hacks;
31 import android.content.Context;
32 import android.media.AudioManager;
35 class LinphoneCoreImpl implements LinphoneCore {
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);
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);
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);
134 LinphoneCoreImpl(LinphoneCoreListener listener, File userConfig,File factoryConfig,Object userdata) throws IOException {
136 nativePtr = newLinphoneCore(listener,userConfig.getCanonicalPath(),factoryConfig.getCanonicalPath(),userdata);
138 LinphoneCoreImpl(LinphoneCoreListener listener) throws IOException {
140 nativePtr = newLinphoneCore(listener,null,null,null);
143 protected void finalize() throws Throwable {
147 private boolean contextInitialized() {
148 if (mContext == null) {
149 Log.e("Context of LinphoneCore has not been initialized, call setContext() after creating LinphoneCore.");
154 public void setContext(Object context) {
155 mContext = (Context)context;
156 mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
159 public synchronized void addAuthInfo(LinphoneAuthInfo info) {
161 addAuthInfo(nativePtr,((LinphoneAuthInfoImpl)info).nativePtr);
164 public synchronized LinphoneProxyConfig getDefaultProxyConfig() {
166 long lNativePtr = getDefaultProxyConfig(nativePtr);
168 return new LinphoneProxyConfigImpl(lNativePtr);
174 public synchronized LinphoneCall invite(String uri) {
176 return (LinphoneCall)invite(nativePtr,uri);
179 public synchronized void iterate() {
184 public synchronized void setDefaultProxyConfig(LinphoneProxyConfig proxyCfg) {
186 setDefaultProxyConfig(nativePtr,((LinphoneProxyConfigImpl)proxyCfg).nativePtr);
188 public synchronized void addProxyConfig(LinphoneProxyConfig proxyCfg) throws LinphoneCoreException{
190 if (addProxyConfig(proxyCfg,nativePtr,((LinphoneProxyConfigImpl)proxyCfg).nativePtr) !=0) {
191 throw new LinphoneCoreException("bad proxy config");
194 public synchronized void clearAuthInfos() {
196 clearAuthInfos(nativePtr);
199 public synchronized void clearProxyConfigs() {
201 clearProxyConfigs(nativePtr);
203 public synchronized void terminateCall(LinphoneCall aCall) {
205 if (aCall!=null)terminateCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr);
207 public synchronized LinphoneAddress getRemoteAddress() {
209 long ptr = getRemoteAddress(nativePtr);
213 return new LinphoneAddressImpl(ptr);
216 public synchronized boolean isIncall() {
218 return isInCall(nativePtr);
220 public synchronized boolean isInComingInvitePending() {
222 return isInComingInvitePending(nativePtr);
224 public synchronized void acceptCall(LinphoneCall aCall) {
226 acceptCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr);
228 public synchronized LinphoneCallLog[] getCallLogs() {
230 LinphoneCallLog[] logs = new LinphoneCallLog[getNumberOfCallLogs(nativePtr)];
231 for (int i=0;i < getNumberOfCallLogs(nativePtr);i++) {
232 logs[i] = new LinphoneCallLogImpl(getCallLog(nativePtr, i));
236 public synchronized void destroy() {
242 private void isValid() {
243 if (nativePtr == 0) {
244 throw new RuntimeException("object already destroyed");
247 public synchronized void setNetworkReachable(boolean isReachable) {
248 setNetworkStateReachable(nativePtr,isReachable);
250 public synchronized void setPlaybackGain(float gain) {
251 setPlaybackGain(nativePtr,gain);
254 public synchronized float getPlaybackGain() {
255 return getPlaybackGain(nativePtr);
257 public synchronized void muteMic(boolean isMuted) {
258 muteMic(nativePtr,isMuted);
261 public synchronized LinphoneAddress interpretUrl(String destination) throws LinphoneCoreException {
262 long lAddress = interpretUrl(nativePtr,destination);
264 return new LinphoneAddressImpl(lAddress,true);
266 throw new LinphoneCoreException("Cannot interpret ["+destination+"]");
269 public synchronized LinphoneCall invite(LinphoneAddress to) throws LinphoneCoreException {
270 LinphoneCall call = (LinphoneCall)inviteAddress(nativePtr,((LinphoneAddressImpl)to).nativePtr);
274 throw new LinphoneCoreException("Unable to invite address " + to.asString());
278 public synchronized void sendDtmf(char number) {
279 sendDtmf(nativePtr,number);
281 public synchronized void clearCallLogs() {
282 clearCallLogs(nativePtr);
284 public synchronized boolean isMicMuted() {
285 return isMicMuted(nativePtr);
287 public synchronized PayloadType findPayloadType(String mime, int clockRate, int channels) {
289 long playLoadType = findPayloadType(nativePtr, mime, clockRate, channels);
290 if (playLoadType == 0) {
293 return new PayloadTypeImpl(playLoadType);
296 public synchronized void enablePayloadType(PayloadType pt, boolean enable)
297 throws LinphoneCoreException {
299 if (enablePayloadType(nativePtr,((PayloadTypeImpl)pt).nativePtr,enable) != 0) {
300 throw new LinphoneCoreException("cannot enable payload type ["+pt+"]");
304 public synchronized void enableEchoCancellation(boolean enable) {
306 enableEchoCancellation(nativePtr, enable);
308 public synchronized boolean isEchoCancellationEnabled() {
310 return isEchoCancellationEnabled(nativePtr);
314 public synchronized LinphoneCall getCurrentCall() {
316 return (LinphoneCall)getCurrentCall(nativePtr);
319 public int getPlayLevel() {
320 // TODO Auto-generated method stub
323 public void setPlayLevel(int level) {
324 // TODO Auto-generated method stub
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);
334 private void setAudioModeIncallForGalaxyS() {
335 if (!contextInitialized()) return;
336 mAudioManager.setMode(MODE_IN_CALL);
338 public void routeAudioToSpeakerHelper(boolean speakerOn) {
339 if (!contextInitialized()) return;
340 if (Hacks.needGalaxySAudioHack())
341 setAudioModeIncallForGalaxyS();
342 mAudioManager.setSpeakerphoneOn(speakerOn);
344 private native void forceSpeakerState(long nativePtr, boolean speakerOn);
345 public void enableSpeaker(boolean value) {
346 final LinphoneCall call = getCurrentCall();
347 mSpeakerEnabled = value;
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);
353 routeAudioToSpeakerHelper(value);
356 public boolean isSpeakerEnabled() {
357 return mSpeakerEnabled;
359 public synchronized void playDtmf(char number, int duration) {
360 playDtmf(nativePtr,number, duration);
363 public synchronized void stopDtmf() {
367 public synchronized void addFriend(LinphoneFriend lf) throws LinphoneCoreException {
368 addFriend(nativePtr,((LinphoneFriendImpl)lf).nativePtr);
371 public synchronized void setPresenceInfo(int minute_away, String alternative_contact,
372 OnlineStatus status) {
373 setPresenceInfo(nativePtr,minute_away,alternative_contact,status.mValue);
376 public synchronized LinphoneChatRoom createChatRoom(String to) {
377 return new LinphoneChatRoomImpl(createChatRoom(nativePtr,to));
379 public synchronized void setPreviewWindow(Object w) {
380 setPreviewWindowId(nativePtr,w);
382 public synchronized void setVideoWindow(Object w) {
383 setVideoWindowId(nativePtr, w);
385 public synchronized void setDeviceRotation(int rotation) {
386 setDeviceRotation(nativePtr, rotation);
389 public synchronized void enableVideo(boolean vcap_enabled, boolean display_enabled) {
390 enableVideo(nativePtr,vcap_enabled, display_enabled);
392 public synchronized boolean isVideoEnabled() {
393 return isVideoEnabled(nativePtr);
395 public synchronized FirewallPolicy getFirewallPolicy() {
396 return FirewallPolicy.fromInt(getFirewallPolicy(nativePtr));
398 public synchronized String getStunServer() {
399 return getStunServer(nativePtr);
401 public synchronized void setFirewallPolicy(FirewallPolicy pol) {
402 setFirewallPolicy(nativePtr,pol.value());
404 public synchronized void setStunServer(String stunServer) {
405 setStunServer(nativePtr,stunServer);
408 public synchronized LinphoneCallParams createDefaultCallParameters() {
409 return new LinphoneCallParamsImpl(createDefaultCallParams(nativePtr));
412 public synchronized LinphoneCall inviteAddressWithParams(LinphoneAddress to, LinphoneCallParams params) throws LinphoneCoreException {
413 long ptrDestination = ((LinphoneAddressImpl)to).nativePtr;
414 long ptrParams =((LinphoneCallParamsImpl)params).nativePtr;
416 LinphoneCall call = (LinphoneCall)inviteAddressWithParams(nativePtr, ptrDestination, ptrParams);
420 throw new LinphoneCoreException("Unable to invite with params " + to.asString());
424 public synchronized int updateCall(LinphoneCall call, LinphoneCallParams params) {
425 long ptrCall = ((LinphoneCallImpl) call).nativePtr;
426 long ptrParams = params!=null ? ((LinphoneCallParamsImpl)params).nativePtr : 0;
428 return updateCall(nativePtr, ptrCall, ptrParams);
430 public synchronized void setUploadBandwidth(int bw) {
431 setUploadBandwidth(nativePtr, bw);
434 public synchronized void setDownloadBandwidth(int bw) {
435 setDownloadBandwidth(nativePtr, bw);
438 public synchronized void setPreferredVideoSize(VideoSize vSize) {
439 setPreferredVideoSize(nativePtr, vSize.width, vSize.height);
442 public synchronized VideoSize getPreferredVideoSize() {
443 int[] nativeSize = getPreferredVideoSize(nativePtr);
445 VideoSize vSize = new VideoSize();
446 vSize.width = nativeSize[0];
447 vSize.height = nativeSize[1];
450 public synchronized void setRing(String path) {
451 setRing(nativePtr, path);
453 public synchronized String getRing() {
454 return getRing(nativePtr);
457 public synchronized void setRootCA(String path) {
458 setRootCA(nativePtr, path);
461 public synchronized LinphoneProxyConfig[] getProxyConfigList() {
462 long[] typesPtr = getProxyConfigList(nativePtr);
463 if (typesPtr == null) return null;
465 LinphoneProxyConfig[] proxies = new LinphoneProxyConfig[typesPtr.length];
467 for (int i=0; i < proxies.length; i++) {
468 proxies[i] = new LinphoneProxyConfigImpl(typesPtr[i]);
474 public synchronized PayloadType[] getVideoCodecs() {
475 long[] typesPtr = listVideoPayloadTypes(nativePtr);
476 if (typesPtr == null) return null;
478 PayloadType[] codecs = new PayloadType[typesPtr.length];
480 for (int i=0; i < codecs.length; i++) {
481 codecs[i] = new PayloadTypeImpl(typesPtr[i]);
486 public synchronized PayloadType[] getAudioCodecs() {
487 long[] typesPtr = listAudioPayloadTypes(nativePtr);
488 if (typesPtr == null) return null;
490 PayloadType[] codecs = new PayloadType[typesPtr.length];
492 for (int i=0; i < codecs.length; i++) {
493 codecs[i] = new PayloadTypeImpl(typesPtr[i]);
498 public synchronized boolean isNetworkReachable() {
499 return isNetworkStateReachable(nativePtr);
502 public synchronized void enableKeepAlive(boolean enable) {
503 enableKeepAlive(nativePtr,enable);
506 public synchronized boolean isKeepAliveEnabled() {
507 return isKeepAliveEnabled(nativePtr);
509 public synchronized void startEchoCalibration(Object data) throws LinphoneCoreException {
510 startEchoCalibration(nativePtr, data);
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
522 public synchronized void setSignalingTransportPorts(Transports transports) {
523 setSignalingTransportPorts(nativePtr, transports.udp, transports.tcp, transports.tls);
526 public synchronized void enableIpv6(boolean enable) {
527 enableIpv6(nativePtr,enable);
529 public synchronized void adjustSoftwareVolume(int i) {
530 //deprecated, does the same as setPlaybackGain().
533 public synchronized boolean pauseCall(LinphoneCall call) {
534 return 0 == pauseCall(nativePtr, ((LinphoneCallImpl) call).nativePtr);
536 public synchronized boolean resumeCall(LinphoneCall call) {
537 return 0 == resumeCall(nativePtr, ((LinphoneCallImpl) call).nativePtr);
539 public synchronized boolean pauseAllCalls() {
540 return 0 == pauseAllCalls(nativePtr);
542 public synchronized void setDownloadPtime(int ptime) {
543 setDownloadPtime(nativePtr,ptime);
546 public synchronized void setUploadPtime(int ptime) {
547 setUploadPtime(nativePtr,ptime);
550 public synchronized void setZrtpSecretsCache(String file) {
551 setZrtpSecretsCache(nativePtr,file);
553 public synchronized void enableEchoLimiter(boolean val) {
554 enableEchoLimiter(nativePtr,val);
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);
562 public int getVideoDevice() {
563 return getVideoDevice(nativePtr);
567 private native void leaveConference(long nativePtr);
568 public synchronized void leaveConference() {
569 leaveConference(nativePtr);
572 private native boolean enterConference(long nativePtr);
573 public synchronized boolean enterConference() {
574 return enterConference(nativePtr);
577 private native boolean isInConference(long nativePtr);
578 public synchronized boolean isInConference() {
579 return isInConference(nativePtr);
582 private native void terminateConference(long nativePtr);
583 public synchronized void terminateConference() {
584 terminateConference(nativePtr);
586 private native int getConferenceSize(long nativePtr);
587 public synchronized int getConferenceSize() {
588 return getConferenceSize(nativePtr);
590 private native int getCallsNb(long nativePtr);
591 public synchronized int getCallsNb() {
592 return getCallsNb(nativePtr);
594 private native void terminateAllCalls(long nativePtr);
595 public synchronized void terminateAllCalls() {
596 terminateAllCalls(nativePtr);
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));
607 private native void addAllToConference(long nativePtr);
608 public synchronized void addAllToConference() {
609 addAllToConference(nativePtr);
612 private native void addToConference(long nativePtr, long nativePtrLcall);
613 public synchronized void addToConference(LinphoneCall call) {
614 addToConference(nativePtr, getCallPtr(call));
617 private native void removeFromConference(long nativePtr, long nativeCallPtr);
618 public synchronized void removeFromConference(LinphoneCall call) {
619 removeFromConference(nativePtr,getCallPtr(call));
622 private long getCallPtr(LinphoneCall call) {
623 return ((LinphoneCallImpl)call).nativePtr;
626 private long getCallParamsPtr(LinphoneCallParams callParams) {
627 return ((LinphoneCallParamsImpl)callParams).nativePtr;
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);
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));
640 private native Object findCallFromUri(long nativePtr, String uri);
642 public synchronized LinphoneCall findCallFromUri(String uri) {
643 return (LinphoneCall) findCallFromUri(nativePtr, uri);
646 public synchronized MediaEncryption getMediaEncryption() {
647 return MediaEncryption.fromInt(getMediaEncryption(nativePtr));
649 public synchronized boolean isMediaEncryptionMandatory() {
650 return isMediaEncryptionMandatory(nativePtr);
652 public synchronized void setMediaEncryption(MediaEncryption menc) {
653 setMediaEncryption(nativePtr, menc.mValue);
655 public synchronized void setMediaEncryptionMandatory(boolean yesno) {
656 setMediaEncryptionMandatory(nativePtr, yesno);
659 private native int getMaxCalls(long nativePtr);
660 public synchronized int getMaxCalls() {
661 return getMaxCalls(nativePtr);
664 public boolean isMyself(String uri) {
665 LinphoneProxyConfig lpc = getDefaultProxyConfig();
666 if (lpc == null) return false;
667 return uri.equals(lpc.getIdentity());
670 private native boolean soundResourcesLocked(long nativePtr);
671 public synchronized boolean soundResourcesLocked() {
672 return soundResourcesLocked(nativePtr);
675 private native void setMaxCalls(long nativePtr, int max);
677 public synchronized void setMaxCalls(int max) {
678 setMaxCalls(nativePtr, max);
680 private native boolean isEchoLimiterEnabled(long nativePtr);
682 public synchronized boolean isEchoLimiterEnabled() {
683 return isEchoLimiterEnabled(nativePtr);
685 private native boolean mediaEncryptionSupported(long nativePtr, int menc);
687 public synchronized boolean mediaEncryptionSupported(MediaEncryption menc) {
688 return mediaEncryptionSupported(nativePtr,menc.mValue);
691 private native void setPlayFile(long nativePtr, String path);
694 public synchronized void setPlayFile(String path) {
695 setPlayFile(nativePtr, path);
699 private native void tunnelAddServerAndMirror(long nativePtr, String host, int port, int mirror, int ms);
701 public synchronized void tunnelAddServerAndMirror(String host, int port, int mirror, int ms) {
702 tunnelAddServerAndMirror(nativePtr, host, port, mirror, ms);
705 private native void tunnelAutoDetect(long nativePtr);
707 public synchronized void tunnelAutoDetect() {
708 tunnelAutoDetect(nativePtr);
711 private native void tunnelCleanServers(long nativePtr);
713 public synchronized void tunnelCleanServers() {
714 tunnelCleanServers(nativePtr);
717 private native void tunnelEnable(long nativePtr, boolean enable);
719 public synchronized void tunnelEnable(boolean enable) {
720 tunnelEnable(nativePtr, enable);
724 public native boolean isTunnelAvailable();
726 private native void acceptCallWithParams(long nativePtr, long aCall,
729 public synchronized void acceptCallWithParams(LinphoneCall aCall,
730 LinphoneCallParams params) throws LinphoneCoreException {
731 acceptCallWithParams(nativePtr, getCallPtr(aCall), getCallParamsPtr(params));
734 private native void acceptCallUpdate(long nativePtr, long aCall, long params);
736 public synchronized void acceptCallUpdate(LinphoneCall aCall, LinphoneCallParams params)
737 throws LinphoneCoreException {
738 acceptCallUpdate(nativePtr, getCallPtr(aCall), getCallParamsPtr(params));
741 private native void deferCallUpdate(long nativePtr, long aCall);
743 public synchronized void deferCallUpdate(LinphoneCall aCall)
744 throws LinphoneCoreException {
745 deferCallUpdate(nativePtr, getCallPtr(aCall));
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);
753 private native void setStaticPicture(long nativePtr, String path);
754 public synchronized void setStaticPicture(String path) {
755 setStaticPicture(nativePtr, path);
757 private native void setUserAgent(long nativePtr, String name, String version);
759 public synchronized void setUserAgent(String name, String version) {
760 setUserAgent(nativePtr,name,version);
763 private native void setCpuCountNative(int count);
764 public synchronized void setCpuCount(int count)
766 setCpuCountNative(count);
769 public synchronized int getMissedCallsCount() {
770 return getMissedCallsCount(nativePtr);
773 public synchronized void removeCallLog(LinphoneCallLog log) {
774 removeCallLog(nativePtr, ((LinphoneCallLogImpl) log).getNativePtr());
777 public synchronized void resetMissedCallsCount() {
778 resetMissedCallsCount(nativePtr);
781 private native void tunnelSetHttpProxy(long nativePtr, String proxy_host, int port,
782 String username, String password);
784 public void tunnelSetHttpProxy(String proxy_host, int port,
785 String username, String password) {
786 tunnelSetHttpProxy(nativePtr, proxy_host, port, username, password);
789 private native void refreshRegisters(long nativePtr);
790 public synchronized void refreshRegisters() {
791 refreshRegisters(nativePtr);
795 public String getVersion() {
796 return getVersion(nativePtr);
799 * Wildcard value used by #linphone_core_find_payload_type to ignore rate in search algorithm
801 static int FIND_PAYLOAD_IGNORE_RATE = -1;
803 * Wildcard value used by #linphone_core_find_payload_type to ignore channel in search algorithm
805 static int FIND_PAYLOAD_IGNORE_CHANNELS = -1;
807 public synchronized PayloadType findPayloadType(String mime, int clockRate) {
808 return findPayloadType(mime, clockRate, FIND_PAYLOAD_IGNORE_CHANNELS);
811 private native void removeFriend(long ptr, long lf);
813 public synchronized void removeFriend(LinphoneFriend lf) {
814 removeFriend(nativePtr, lf.getNativePtr());
817 private native long getFriendByAddress(long ptr, String sipUri);
819 public synchronized LinphoneFriend findFriendByAddress(String sipUri) {
820 long ptr = getFriendByAddress(nativePtr, sipUri);
824 return new LinphoneFriendImpl(ptr);
827 public synchronized void setAudioPort(int port) {
828 setAudioPort(nativePtr, port);
831 public synchronized void setVideoPort(int port) {
832 setVideoPort(nativePtr, port);
835 public synchronized void setAudioPortRange(int minPort, int maxPort) {
836 setAudioPortRange(nativePtr, minPort, maxPort);
839 public synchronized void setVideoPortRange(int minPort, int maxPort) {
840 setVideoPortRange(nativePtr, minPort, maxPort);
843 public synchronized void setIncomingTimeout(int timeout) {
844 setIncomingTimeout(nativePtr, timeout);
847 public synchronized void setInCallTimeout(int timeout)
849 setInCallTimeout(nativePtr, timeout);
852 private native void setMicrophoneGain(long ptr, float gain);
853 public synchronized void setMicrophoneGain(float gain) {
854 setMicrophoneGain(nativePtr, gain);
857 public synchronized void setPrimaryContact(String displayName, String username) {
858 setPrimaryContact(nativePtr, displayName, username);
861 private native void setUseSipInfoForDtmfs(long ptr, boolean use);
862 public synchronized void setUseSipInfoForDtmfs(boolean use) {
863 setUseSipInfoForDtmfs(nativePtr, use);
866 private native void setUseRfc2833ForDtmfs(long ptr, boolean use);
867 public synchronized void setUseRfc2833ForDtmfs(boolean use) {
868 setUseRfc2833ForDtmfs(nativePtr, use);
871 private native long getConfig(long ptr);
872 public synchronized LpConfig getConfig() {
873 long configPtr=getConfig(nativePtr);
874 return new LpConfigImpl(configPtr);
876 private native boolean needsEchoCalibration(long ptr);
878 public synchronized boolean needsEchoCalibration() {
879 return needsEchoCalibration(nativePtr);
881 private native void declineCall(long coreptr, long callptr, int reason);
883 public synchronized void declineCall(LinphoneCall aCall, Reason reason) {
884 declineCall(nativePtr,((LinphoneCallImpl)aCall).nativePtr,reason.mValue);
887 private native boolean upnpAvailable(long ptr);
888 public boolean upnpAvailable() {
889 return upnpAvailable(nativePtr);
892 private native int getUpnpState(long ptr);
893 public UpnpState getUpnpState() {
894 return UpnpState.fromInt(getUpnpState(nativePtr));
897 private native String getUpnpExternalIpaddress(long ptr);
898 public String getUpnpExternalIpaddress() {
899 return getUpnpExternalIpaddress(nativePtr);
901 private native int startConferenceRecording(long nativePtr, String path);
903 public void startConferenceRecording(String path) {
904 startConferenceRecording(nativePtr,path);
907 private native int stopConferenceRecording(long nativePtr);
909 public void stopConferenceRecording() {
910 stopConferenceRecording(nativePtr);
913 public PayloadType findPayloadType(String mime) {
914 return findPayloadType(mime, FIND_PAYLOAD_IGNORE_RATE);
917 private native void setSipDscp(long nativePtr, int dscp);
919 public void setSipDscp(int dscp) {
920 setSipDscp(nativePtr,dscp);
923 private native int getSipDscp(long nativePtr);
925 public int getSipDscp() {
926 return getSipDscp(nativePtr);
928 private native void setAudioDscp(long nativePtr, int dscp);
930 public void setAudioDscp(int dscp) {
931 setAudioDscp(nativePtr, dscp);
934 private native int getAudioDscp(long nativePtr);
936 public int getAudioDscp() {
937 return getAudioDscp(nativePtr);
940 private native void setVideoDscp(long nativePtr, int dscp);
942 public void setVideoDscp(int dscp) {
943 setVideoDscp(nativePtr,dscp);
946 private native int getVideoDscp(long nativePtr);
948 public int getVideoDscp() {
949 return getVideoDscp(nativePtr);