diff --git a/coreapi/linphone_tunnel.cc b/coreapi/linphone_tunnel.cc index 7dd27d890..6cedfc2fd 100644 --- a/coreapi/linphone_tunnel.cc +++ b/coreapi/linphone_tunnel.cc @@ -162,7 +162,7 @@ static void linphone_tunnel_add_server_intern(LinphoneTunnel *tunnel, LinphoneTu linphone_tunnel_config_get_remote_udp_mirror_port(tunnel_config), linphone_tunnel_config_get_delay(tunnel_config)); } - tunnel->config_list = ms_list_append(tunnel->config_list, tunnel_config); + tunnel->config_list = ms_list_append(tunnel->config_list, linphone_tunnel_config_ref(tunnel_config)); } @@ -211,7 +211,7 @@ void linphone_tunnel_remove_server(LinphoneTunnel *tunnel, LinphoneTunnelConfig MSList *elem = ms_list_find(tunnel->config_list, tunnel_config); if(elem != NULL) { tunnel->config_list = ms_list_remove(tunnel->config_list, tunnel_config); - linphone_tunnel_config_destroy(tunnel_config); + linphone_tunnel_config_unref(tunnel_config); linphone_tunnel_refresh_config(tunnel); linphone_tunnel_save_config(tunnel); } diff --git a/coreapi/linphone_tunnel.h b/coreapi/linphone_tunnel.h index 5e6640e8d..f95701b80 100644 --- a/coreapi/linphone_tunnel.h +++ b/coreapi/linphone_tunnel.h @@ -196,6 +196,20 @@ LINPHONE_PUBLIC void linphone_tunnel_config_unref(LinphoneTunnelConfig *cfg); */ LINPHONE_PUBLIC void linphone_tunnel_config_destroy(LinphoneTunnelConfig *tunnel); +/** + * Store a user data in the tunnel config object + * @param cfg the tunnel config + * @param ud the user data +**/ +LINPHONE_PUBLIC void linphone_tunnel_config_set_user_data(LinphoneTunnelConfig *cfg, void *ud); + +/** + * Retrieve user data from the tunnel config + * @param cfg the tunnel config + * @return the user data +**/ +LINPHONE_PUBLIC void *linphone_tunnel_config_get_user_data(LinphoneTunnelConfig *cfg); + /** * Add a tunnel server configuration. * @param tunnel LinphoneTunnel object diff --git a/coreapi/linphone_tunnel_config.c b/coreapi/linphone_tunnel_config.c index bf836e797..988b114a1 100644 --- a/coreapi/linphone_tunnel_config.c +++ b/coreapi/linphone_tunnel_config.c @@ -37,6 +37,7 @@ LinphoneTunnelConfig *linphone_tunnel_config_new() { LinphoneTunnelConfig *ltc = belle_sip_object_new(LinphoneTunnelConfig); ltc->remote_udp_mirror_port = 12345; ltc->delay = 1000; + ltc->port = 443; return ltc; } diff --git a/coreapi/linphonecore_jni.cc b/coreapi/linphonecore_jni.cc index 3390df536..45f796816 100644 --- a/coreapi/linphonecore_jni.cc +++ b/coreapi/linphonecore_jni.cc @@ -90,6 +90,7 @@ static jobject handler_obj=NULL; static jobject create_java_linphone_content(JNIEnv *env, const LinphoneContent *content); static jobject create_java_linphone_buffer(JNIEnv *env, const LinphoneBuffer *buffer); static LinphoneBuffer* create_c_linphone_buffer_from_java_linphone_buffer(JNIEnv *env, jobject jbuffer); +static jobject getTunnelConfig(JNIEnv *env, LinphoneTunnelConfig *cfg); #ifdef ANDROID void linphone_android_log_handler(int prio, char *str) { @@ -171,6 +172,14 @@ extern "C" void Java_org_linphone_core_LinphoneCoreFactoryImpl_setDebugMode(JNIE } } +extern "C" jobject Java_org_linphone_core_LinphoneCoreFactoryImpl__1createTunnelConfig(JNIEnv* env, jobject thiz){ + jobject jobj; + LinphoneTunnelConfig *cfg = linphone_tunnel_config_new(); + jobj = getTunnelConfig(env, cfg); //this will take a ref. + linphone_tunnel_config_unref(cfg); + return jobj; +} + extern "C" void Java_org_linphone_core_LinphoneCoreFactoryImpl_enableLogCollection(JNIEnv* env ,jobject thiz ,jboolean enable) { @@ -3776,6 +3785,15 @@ extern "C" jlong Java_org_linphone_core_LinphoneCoreImpl_createDefaultCallParams return (jlong) linphone_core_create_default_call_parameters((LinphoneCore*)lc); } +/* + * Class: org_linphone_core_LinphoneCoreImpl + * Method: createCallParams + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_linphone_core_LinphoneCoreImpl_createCallParams(JNIEnv *env, jobject jcore, jlong coreptr, jlong callptr){ + return (jlong)linphone_core_create_call_params((LinphoneCore*)coreptr, (LinphoneCall*)callptr); +} + extern "C" jlong Java_org_linphone_core_LinphoneCallImpl_getRemoteParams(JNIEnv *env, jobject thiz, jlong lc){ if (linphone_call_get_remote_params((LinphoneCall*)lc) == NULL) { return (jlong) 0; @@ -4244,24 +4262,7 @@ extern "C" void Java_org_linphone_core_LinphoneCoreImpl_tunnelAddServerAndMirror extern "C" void Java_org_linphone_core_LinphoneCoreImpl_tunnelAddServer(JNIEnv *env, jobject thiz, jlong pCore, jobject config) { LinphoneTunnel *tunnel = linphone_core_get_tunnel((LinphoneCore *)pCore); if(tunnel != NULL) { - jclass TunnelConfigClass = env->FindClass("org/linphone/core/TunnelConfig"); - jmethodID getHostMethod = env->GetMethodID(TunnelConfigClass, "getHost", "()Ljava/lang/String;"); - jmethodID getPortMethod = env->GetMethodID(TunnelConfigClass, "getPort", "()I"); - jmethodID getRemoteUdpMirrorPortMethod = env->GetMethodID(TunnelConfigClass, "getRemoteUdpMirrorPort", "()I"); - jmethodID getDelayMethod = env->GetMethodID(TunnelConfigClass, "getDelay", "()I"); - jstring hostString = (jstring)env->CallObjectMethod(config, getHostMethod); - const char *host = env->GetStringUTFChars(hostString, NULL); - if(host == NULL || strlen(host)==0) { - ms_error("LinphoneCore.tunnelAddServer(): no tunnel host defined"); - } - LinphoneTunnelConfig *tunnelConfig = linphone_tunnel_config_new(); - linphone_tunnel_config_set_host(tunnelConfig, host); - linphone_tunnel_config_set_port(tunnelConfig, env->CallIntMethod(config, getPortMethod)); - linphone_tunnel_config_set_remote_udp_mirror_port(tunnelConfig, env->CallIntMethod(config, getRemoteUdpMirrorPortMethod)); - linphone_tunnel_config_set_delay(tunnelConfig, env->CallIntMethod(config, getDelayMethod)); - linphone_tunnel_add_server(tunnel, tunnelConfig); - env->ReleaseStringUTFChars(hostString, host); - env->DeleteLocalRef(TunnelConfigClass); + } else { ms_error("LinphoneCore.tunnelAddServer(): tunnel feature is not enabled"); } @@ -4269,31 +4270,21 @@ extern "C" void Java_org_linphone_core_LinphoneCoreImpl_tunnelAddServer(JNIEnv * extern "C" jobjectArray Java_org_linphone_core_LinphoneCoreImpl_tunnelGetServers(JNIEnv *env, jobject thiz, jlong pCore) { LinphoneTunnel *tunnel = linphone_core_get_tunnel((LinphoneCore *)pCore); - jclass TunnelConfigClass = env->FindClass("org/linphone/core/TunnelConfig"); - jmethodID setHostMethod = env->GetMethodID(TunnelConfigClass, "setHost", "(Ljava/lang/String;)V"); - jmethodID setPortMethod = env->GetMethodID(TunnelConfigClass, "setPort", "(I)V"); - jmethodID setRemoteUdpMirrorPortMethod = env->GetMethodID(TunnelConfigClass, "setRemoteUdpMirrorPort", "(I)V"); - jmethodID setDelayMethod = env->GetMethodID(TunnelConfigClass, "setDelay", "(I)V"); + jclass tunnelConfigClass = env->FindClass("org/linphone/core/TunnelConfigImpl"); jobjectArray tunnelConfigArray = NULL; if(tunnel != NULL) { const MSList *servers = linphone_tunnel_get_servers(tunnel); const MSList *it; int i; - ms_message("servers=%p", (void *)servers); - ms_message("taille=%i", ms_list_size(servers)); - tunnelConfigArray = env->NewObjectArray(ms_list_size(servers), TunnelConfigClass, NULL); + tunnelConfigArray = env->NewObjectArray(ms_list_size(servers), tunnelConfigClass, NULL); for(it = servers, i=0; it != NULL; it = it->next, i++) { - const LinphoneTunnelConfig *conf = (const LinphoneTunnelConfig *)it->data; - jobject elt = env->AllocObject(TunnelConfigClass); - env->CallVoidMethod(elt, setHostMethod, env->NewStringUTF(linphone_tunnel_config_get_host(conf))); - env->CallVoidMethod(elt, setPortMethod, linphone_tunnel_config_get_port(conf)); - env->CallVoidMethod(elt, setRemoteUdpMirrorPortMethod, linphone_tunnel_config_get_remote_udp_mirror_port(conf)); - env->CallVoidMethod(elt, setDelayMethod, linphone_tunnel_config_get_delay(conf)); + LinphoneTunnelConfig *conf = (LinphoneTunnelConfig *)it->data; + jobject elt = getTunnelConfig(env, conf); env->SetObjectArrayElement(tunnelConfigArray, i, elt); - env->DeleteLocalRef(TunnelConfigClass); } } + env->DeleteLocalRef(tunnelConfigClass); return tunnelConfigArray; } @@ -6321,3 +6312,134 @@ JNIEXPORT void JNICALL Java_org_linphone_core_LinphoneCallImpl_setListener(JNIEn LinphoneCall *call = (LinphoneCall *)ptr; linphone_call_set_next_video_frame_decoded_callback(call, _next_video_frame_decoded_callback, listener); } + + +/* + * returns the java TunnelConfig associated with a C LinphoneTunnelConfig. +**/ +static jobject getTunnelConfig(JNIEnv *env, LinphoneTunnelConfig *cfg){ + jobject jobj=0; + + if (cfg != NULL){ + jclass tunnelConfigClass = env->FindClass("org/linphone/core/TunnelConfigImpl"); + jmethodID ctor = env->GetMethodID(tunnelConfigClass,"", "(j)V"); + + void *up=linphone_tunnel_config_get_user_data(cfg); + + if (up==NULL){ + jobj=env->NewObject(tunnelConfigClass,ctor,(jlong)cfg); + linphone_tunnel_config_set_user_data(cfg,(void*)env->NewWeakGlobalRef(jobj)); + linphone_tunnel_config_ref(cfg); + }else{ + //promote the weak ref to local ref + jobj=env->NewLocalRef((jobject)up); + if (jobj == NULL){ + //the weak ref was dead + jobj=env->NewObject(tunnelConfigClass,ctor,(jlong)cfg); + linphone_tunnel_config_set_user_data(cfg,(void*)env->NewWeakGlobalRef(jobj)); + } + } + env->DeleteLocalRef(tunnelConfigClass); + } + return jobj; +} + + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: getHost + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_linphone_core_TunnelConfigImpl_getHost(JNIEnv *env, jobject obj, jlong ptr){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + const char *host = linphone_tunnel_config_get_host(cfg); + if (host){ + return env->NewStringUTF(host); + } + return NULL; +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: setHost + * Signature: (JLjava/lang/String;)V + */ +JNIEXPORT void JNICALL Java_org_linphone_core_TunnelConfigImpl_setHost(JNIEnv *env, jobject obj, jlong ptr, jstring jstr){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + const char* host = jstr ? env->GetStringUTFChars(jstr, NULL) : NULL; + linphone_tunnel_config_set_host(cfg, host); + if (jstr) env->ReleaseStringUTFChars(jstr, host); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: getPort + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_linphone_core_TunnelConfigImpl_getPort(JNIEnv *env, jobject jobj, jlong ptr){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + return linphone_tunnel_config_get_port(cfg); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: setPort + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_linphone_core_TunnelConfigImpl_setPort(JNIEnv *env, jobject jobj, jlong ptr, jint port){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + linphone_tunnel_config_set_port(cfg, port); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: getRemoteUdpMirrorPort + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_linphone_core_TunnelConfigImpl_getRemoteUdpMirrorPort(JNIEnv *env, jobject jobj, jlong ptr){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + return linphone_tunnel_config_get_remote_udp_mirror_port(cfg); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: setRemoteUdpMirrorPort + * Signature: (JI)V + */ +JNIEXPORT void JNICALL Java_org_linphone_core_TunnelConfigImpl_setRemoteUdpMirrorPort(JNIEnv *env, jobject jobj, jlong ptr, jint port){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + linphone_tunnel_config_set_remote_udp_mirror_port(cfg, port); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: getDelay + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_linphone_core_TunnelConfigImpl_getDelay(JNIEnv *env, jobject jobj, jlong ptr){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + return linphone_tunnel_config_get_delay(cfg); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: setDelay + * Signature: (JI)I + */ +JNIEXPORT void JNICALL Java_org_linphone_core_TunnelConfigImpl_setDelay(JNIEnv *env, jobject jobj, jlong ptr, jint delay){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + linphone_tunnel_config_set_delay(cfg, delay); +} + +/* + * Class: org_linphone_core_TunnelConfigImpl + * Method: destroy + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_org_linphone_core_TunnelConfigImpl_destroy(JNIEnv *env, jobject jobj, jlong ptr){ + LinphoneTunnelConfig *cfg = (LinphoneTunnelConfig *)ptr; + linphone_tunnel_config_set_user_data(cfg, NULL); + linphone_tunnel_config_unref(cfg); +} + + diff --git a/java/common/org/linphone/core/LinphoneCore.java b/java/common/org/linphone/core/LinphoneCore.java index f562fd582..8d4a8c1e2 100644 --- a/java/common/org/linphone/core/LinphoneCore.java +++ b/java/common/org/linphone/core/LinphoneCore.java @@ -1127,9 +1127,20 @@ public interface LinphoneCore { /** * Get default call parameters reflecting current linphone core configuration * @return LinphoneCallParams + * @deprecated use LinphoneCore.createCallParams(). */ LinphoneCallParams createDefaultCallParameters(); + /** + * Create a LinphoneCallParams suitable to be used for a new incoming call or an established call, in + * methods LinphoneCore.inviteAddressWithParams(), LinphoneCore.updateCall(), LinphoneCore.acceptCallWithParams(), LinphoneCore.acceptCallUpdate(). + * The call parameter is optional: when creating a LinphoneCallParams for an outgoing call that is about to be created, + * it shall be set to null. + * @param call (optional) + * @return a LinphoneCallParams object, representing the call settings guessed from the current LinphoneCore and compatible with the call object if any. + */ + LinphoneCallParams createCallParams(LinphoneCall call); + /** * Sets the path to a wav file used for ringing. * diff --git a/java/common/org/linphone/core/LinphoneCoreFactory.java b/java/common/org/linphone/core/LinphoneCoreFactory.java index 8019ec7bd..88a7651e4 100644 --- a/java/common/org/linphone/core/LinphoneCoreFactory.java +++ b/java/common/org/linphone/core/LinphoneCoreFactory.java @@ -167,4 +167,9 @@ abstract public class LinphoneCoreFactory { abstract public PresenceModel createPresenceModel(); abstract public PresenceModel createPresenceModel(PresenceActivityType type, String description); abstract public PresenceModel createPresenceModel(PresenceActivityType type, String description, String note, String lang); + + /* + * Create TunnelConfig object, used to configure voip anti blocking extension. + */ + abstract public TunnelConfig createTunnelConfig(); } diff --git a/java/common/org/linphone/core/TunnelConfig.java b/java/common/org/linphone/core/TunnelConfig.java new file mode 100644 index 000000000..a7eb28c3f --- /dev/null +++ b/java/common/org/linphone/core/TunnelConfig.java @@ -0,0 +1,53 @@ +package org.linphone.core; + +/** + * The TunnelConfig interface allows to configure information about a tunnel server (voip anti blocking). + * @author smorlat + * + */ +public interface TunnelConfig { + /** + * Get the hostname of the tunnel server + * @return + */ + String getHost(); + /** + * Set the hostname (or ip address) of the tunnel server. + * @param host + */ + void setHost(String host); + /** + * Get the port where to connect. + * @return + */ + int getPort(); + /** + * Set the port where to connect to the tunnel server. + * When not set, the default value is used (443). + * @param port + */ + void setPort(int port); + /** + * Get the remote udp mirror port, which is used to check udp connectivity of the network. + * @return + */ + int getRemoteUdpMirrorPort(); + /** + * Set the udp mirror port, which is used to check udp connectivity. + * When not set, a default value of 12345 is used. + * @param remoteUdpMirrorPort + */ + void setRemoteUdpMirrorPort(int remoteUdpMirrorPort); + /** + * Get the maximum amount of time for waiting for UDP packets to come back during + * the UDP connectivity check, in milliseconds. + * + * @return + */ + int getDelay(); + /** + * Set the maximum amount of time for waiting for UDP packets to come back during + * the UDP connectivity check, in milliseconds. + */ + void setDelay(int delay); +} diff --git a/java/impl/org/linphone/core/LinphoneCoreFactoryImpl.java b/java/impl/org/linphone/core/LinphoneCoreFactoryImpl.java index 0d6fc777b..7bb174ed4 100644 --- a/java/impl/org/linphone/core/LinphoneCoreFactoryImpl.java +++ b/java/impl/org/linphone/core/LinphoneCoreFactoryImpl.java @@ -193,4 +193,10 @@ public class LinphoneCoreFactoryImpl extends LinphoneCoreFactory { public PresenceModel createPresenceModel(PresenceActivityType type, String description, String note, String lang) { return new PresenceModelImpl(type, description, note, lang); } + + private native Object _createTunnelConfig(); + @Override + public TunnelConfig createTunnelConfig() { + return (TunnelConfig)_createTunnelConfig(); + } } diff --git a/java/impl/org/linphone/core/LinphoneCoreImpl.java b/java/impl/org/linphone/core/LinphoneCoreImpl.java index 26db34e86..1bc381f9c 100644 --- a/java/impl/org/linphone/core/LinphoneCoreImpl.java +++ b/java/impl/org/linphone/core/LinphoneCoreImpl.java @@ -1517,4 +1517,12 @@ class LinphoneCoreImpl implements LinphoneCore { public String getVideoPreset() { return getVideoPreset(nativePtr); } + private native long createCallParams(long nativePtr, long callPtr); + @Override + public LinphoneCallParams createCallParams(LinphoneCall call) { + long callptr = 0; + if (call!=null) callptr = ((LinphoneCallImpl)call).nativePtr; + long ptr = createCallParams(nativePtr, callptr); + return new LinphoneCallParamsImpl(ptr); + } } diff --git a/java/impl/org/linphone/core/TunnelConfig.java b/java/impl/org/linphone/core/TunnelConfig.java deleted file mode 100644 index 9801f0fbd..000000000 --- a/java/impl/org/linphone/core/TunnelConfig.java +++ /dev/null @@ -1,40 +0,0 @@ -package org.linphone.core; - -public class TunnelConfig { - private String host = null; - private int port = 443; - private int remoteUdpMirrorPort = 12345; - private int delay = 1000; - - public String getHost() { - return host; - } - - public void setHost(String host) { - this.host = host; - } - - public int getPort() { - return port; - } - - public void setPort(int port) { - this.port = port; - } - - public int getRemoteUdpMirrorPort() { - return remoteUdpMirrorPort; - } - - public void setRemoteUdpMirrorPort(int remoteUdpMirrorPort) { - this.remoteUdpMirrorPort = remoteUdpMirrorPort; - } - - public int getDelay() { - return delay; - } - - public void setDelay(int delay) { - this.delay = delay; - } -}