diff --git a/coreapi/account_creator.c b/coreapi/account_creator.c index 931c332ab..78a5e1d2b 100644 --- a/coreapi/account_creator.c +++ b/coreapi/account_creator.c @@ -705,7 +705,7 @@ LinphoneAccountCreatorStatus linphone_account_creator_activate_phone_number_link LinphoneXmlRpcArgString, ha1_for_passwd(creator->username, creator->password, creator->domain), LinphoneXmlRpcArgNone); linphone_xml_rpc_request_set_user_data(request, creator); - linphone_xml_rpc_request_cbs_set_response(linphone_xml_rpc_request_get_callbacks(request), _is_account_activated_cb); + linphone_xml_rpc_request_cbs_set_response(linphone_xml_rpc_request_get_callbacks(request), _activate_phone_number_link_cb); linphone_xml_rpc_session_send_request(creator->xmlrpc_session, request); linphone_xml_rpc_request_unref(request); return LinphoneAccountCreatorOK; diff --git a/coreapi/linphonecore_jni.cc b/coreapi/linphonecore_jni.cc index 0d3a90472..a18c4480c 100644 --- a/coreapi/linphonecore_jni.cc +++ b/coreapi/linphonecore_jni.cc @@ -33,6 +33,7 @@ extern "C" { } #include "mediastreamer2/msjava.h" #include "private.h" +#include "account_creator.h" #include #include "lpconfig.h" @@ -312,6 +313,11 @@ public: msFactoryClass = (jclass)env->NewGlobalRef(env->FindClass("org/linphone/mediastream/Factory")); msFactoryCtrId = env->GetMethodID(msFactoryClass,"", "(J)V"); + + accountCreatorClass = (jclass)env->NewGlobalRef(env->FindClass("org/linphone/core/LinphoneAccountCreatorImpl")); + accountCreatorCtrId = env->GetMethodID(accountCreatorClass, "", "(J)V"); + accountCreatorStatusClass = (jclass)env->NewGlobalRef(env->FindClass("org/linphone/core/LinphoneAccountCreator$Status")); + accountCreatorStatusFromIntId = env->GetStaticMethodID(accountCreatorStatusClass,"fromInt","(I)Lorg/linphone/core/LinphoneAccountCreator$Status;"); } void setCore(jobject c) { @@ -344,6 +350,8 @@ public: env->DeleteGlobalRef(subscriptionDirClass); env->DeleteGlobalRef(logCollectionUploadStateClass); env->DeleteGlobalRef(msFactoryClass); + env->DeleteGlobalRef(accountCreatorClass); + env->DeleteGlobalRef(accountCreatorStatusClass); } jobject core; @@ -447,6 +455,11 @@ public: jclass msFactoryClass; jmethodID msFactoryCtrId; + + jclass accountCreatorClass; + jmethodID accountCreatorCtrId; + jclass accountCreatorStatusClass; + jmethodID accountCreatorStatusFromIntId; }; /* @@ -642,6 +655,29 @@ jobject getEvent(JNIEnv *env, LinphoneEvent *lev){ return jev; } +jobject getAccountCreator(JNIEnv *env, LinphoneAccountCreator *account_creator) { + jobject jobj = 0; + + if (account_creator != NULL) { + LinphoneCore *lc = account_creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + void *up = linphone_account_creator_get_user_data(account_creator); + if (up == NULL) { + jobj = env->NewObject(ljb->natPolicyClass, ljb->natPolicyCtrId, (jlong)account_creator); + linphone_account_creator_set_user_data(account_creator, (void *)env->NewWeakGlobalRef(jobj)); + linphone_account_creator_ref(account_creator); + } else { + jobj = env->NewLocalRef((jobject)up); + if (jobj == NULL) { + jobj = env->NewObject(ljb->natPolicyClass, ljb->natPolicyCtrId, (jlong)account_creator); + linphone_account_creator_set_user_data(account_creator, (void *)env->NewWeakGlobalRef(jobj)); + } + } + } + return jobj; +} + class LinphoneCoreData { public: LinphoneCoreData(JNIEnv *env, jobject lc, LinphoneCoreVTable *vTable, jobject alistener, LinphoneJavaBindings *ljb) { @@ -7539,3 +7575,348 @@ JNIEXPORT void JNICALL Java_org_linphone_core_LinphoneNatPolicyImpl_setStunServe linphone_nat_policy_set_stun_server_username(nat_policy, stun_server_username); ReleaseStringUTFChars(env, jStunServerUsername, stun_server_username); } + +// Account creator + +static void account_creator_is_account_used(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status) { + JNIEnv *env = 0; + jint result = jvm->AttachCurrentThread(&env,NULL); + if (result != 0) { + ms_error("cannot attach VM\n"); + return; + } + + LinphoneAccountCreatorCbs *cbs = linphone_account_creator_get_callbacks(creator); + jobject listener = (jobject) linphone_account_creator_cbs_get_user_data(cbs); + if (listener == NULL) { + ms_error("account_creator_response() notification without listener"); + return ; + } + + LinphoneCore *lc = (LinphoneCore *)creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + jclass clazz = (jclass) env->GetObjectClass(listener); + jmethodID method = env->GetMethodID(clazz, "onAccountCreatorIsAccountUsed","(Lorg/linphone/core/LinphoneAccountCreator;Lorg/linphone/core/LinphoneAccountCreator$Status)V"); + env->DeleteLocalRef(clazz); + + jobject statusObject = env->CallStaticObjectMethod(ljb->accountCreatorStatusClass, ljb->accountCreatorStatusFromIntId, (jint)status); + env->CallVoidMethod(listener, method, getAccountCreator(env, creator), statusObject); +} + +static void account_creator_create_account(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status) { + JNIEnv *env = 0; + jint result = jvm->AttachCurrentThread(&env,NULL); + if (result != 0) { + ms_error("cannot attach VM\n"); + return; + } + + LinphoneAccountCreatorCbs *cbs = linphone_account_creator_get_callbacks(creator); + jobject listener = (jobject) linphone_account_creator_cbs_get_user_data(cbs); + if (listener == NULL) { + ms_error("account_creator_response() notification without listener"); + return ; + } + + LinphoneCore *lc = (LinphoneCore *)creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + jclass clazz = (jclass) env->GetObjectClass(listener); + jmethodID method = env->GetMethodID(clazz, "onAccountCreatorAccountCreated","(Lorg/linphone/core/LinphoneAccountCreator;Lorg/linphone/core/LinphoneAccountCreator$Status)V"); + env->DeleteLocalRef(clazz); + + jobject statusObject = env->CallStaticObjectMethod(ljb->accountCreatorStatusClass, ljb->accountCreatorStatusFromIntId, (jint)status); + env->CallVoidMethod(listener, method, getAccountCreator(env, creator), statusObject); +} + +static void account_creator_activate_account(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status) { + JNIEnv *env = 0; + jint result = jvm->AttachCurrentThread(&env,NULL); + if (result != 0) { + ms_error("cannot attach VM\n"); + return; + } + + LinphoneAccountCreatorCbs *cbs = linphone_account_creator_get_callbacks(creator); + jobject listener = (jobject) linphone_account_creator_cbs_get_user_data(cbs); + if (listener == NULL) { + ms_error("account_creator_response() notification without listener"); + return ; + } + + LinphoneCore *lc = (LinphoneCore *)creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + jclass clazz = (jclass) env->GetObjectClass(listener); + jmethodID method = env->GetMethodID(clazz, "onAccountCreatorAccountActivated","(Lorg/linphone/core/LinphoneAccountCreator;Lorg/linphone/core/LinphoneAccountCreator$Status)V"); + env->DeleteLocalRef(clazz); + + jobject statusObject = env->CallStaticObjectMethod(ljb->accountCreatorStatusClass, ljb->accountCreatorStatusFromIntId, (jint)status); + env->CallVoidMethod(listener, method, getAccountCreator(env, creator), statusObject); +} + +static void account_creator_link_phone_number_with_account(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status) { + JNIEnv *env = 0; + jint result = jvm->AttachCurrentThread(&env,NULL); + if (result != 0) { + ms_error("cannot attach VM\n"); + return; + } + + LinphoneAccountCreatorCbs *cbs = linphone_account_creator_get_callbacks(creator); + jobject listener = (jobject) linphone_account_creator_cbs_get_user_data(cbs); + if (listener == NULL) { + ms_error("account_creator_response() notification without listener"); + return ; + } + + LinphoneCore *lc = (LinphoneCore *)creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + jclass clazz = (jclass) env->GetObjectClass(listener); + jmethodID method = env->GetMethodID(clazz, "onAccountCreatorAccountLinkedWithPhoneNumber","(Lorg/linphone/core/LinphoneAccountCreator;Lorg/linphone/core/LinphoneAccountCreator$Status)V"); + env->DeleteLocalRef(clazz); + + jobject statusObject = env->CallStaticObjectMethod(ljb->accountCreatorStatusClass, ljb->accountCreatorStatusFromIntId, (jint)status); + env->CallVoidMethod(listener, method, getAccountCreator(env, creator), statusObject); +} + +static void account_creator_activate_phone_number_link(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status) { + JNIEnv *env = 0; + jint result = jvm->AttachCurrentThread(&env,NULL); + if (result != 0) { + ms_error("cannot attach VM\n"); + return; + } + + LinphoneAccountCreatorCbs *cbs = linphone_account_creator_get_callbacks(creator); + jobject listener = (jobject) linphone_account_creator_cbs_get_user_data(cbs); + if (listener == NULL) { + ms_error("account_creator_response() notification without listener"); + return ; + } + + LinphoneCore *lc = (LinphoneCore *)creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + jclass clazz = (jclass) env->GetObjectClass(listener); + jmethodID method = env->GetMethodID(clazz, "onAccountCreatorPhoneNumberLinkActivated","(Lorg/linphone/core/LinphoneAccountCreator;Lorg/linphone/core/LinphoneAccountCreator$Status)V"); + env->DeleteLocalRef(clazz); + + jobject statusObject = env->CallStaticObjectMethod(ljb->accountCreatorStatusClass, ljb->accountCreatorStatusFromIntId, (jint)status); + env->CallVoidMethod(listener, method, getAccountCreator(env, creator), statusObject); +} + +static void account_creator_is_account_activated(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status) { + JNIEnv *env = 0; + jint result = jvm->AttachCurrentThread(&env,NULL); + if (result != 0) { + ms_error("cannot attach VM\n"); + return; + } + + LinphoneAccountCreatorCbs *cbs = linphone_account_creator_get_callbacks(creator); + jobject listener = (jobject) linphone_account_creator_cbs_get_user_data(cbs); + if (listener == NULL) { + ms_error("account_creator_response() notification without listener"); + return ; + } + + LinphoneCore *lc = (LinphoneCore *)creator->core; + LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc); + + jclass clazz = (jclass) env->GetObjectClass(listener); + jmethodID method = env->GetMethodID(clazz, "onAccountCreatorIsAccountActivated","(Lorg/linphone/core/LinphoneAccountCreator;Lorg/linphone/core/LinphoneAccountCreator$Status)V"); + env->DeleteLocalRef(clazz); + + jobject statusObject = env->CallStaticObjectMethod(ljb->accountCreatorStatusClass, ljb->accountCreatorStatusFromIntId, (jint)status); + env->CallVoidMethod(listener, method, getAccountCreator(env, creator), statusObject); +} + +extern "C" jlong Java_org_linphone_core_LinphoneAccountCreatorImpl_newLinphoneAccountCreator(JNIEnv *env, jobject thiz, jlong core, jstring jurl) { + const char *url = GetStringUTFChars(env, jurl); + LinphoneAccountCreator *account_creator = linphone_account_creator_new((LinphoneCore *)core, url); + ReleaseStringUTFChars(env, jurl, url); + return (jlong) account_creator; +} + +extern "C" void Java_org_linphone_core_LinphoneAccountCreatorImpl_unref(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + linphone_account_creator_set_user_data(account_creator, NULL); + linphone_account_creator_unref(account_creator); +} + +extern "C" void Java_org_linphone_core_LinphoneAccountCreatorImpl_setListener(JNIEnv* env, jobject thiz, jlong ptr, jobject jlistener) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + jobject listener = env->NewGlobalRef(jlistener); + LinphoneAccountCreatorCbs *cbs; + + cbs = linphone_account_creator_get_callbacks(account_creator); + linphone_account_creator_cbs_set_user_data(cbs, listener); + linphone_account_creator_cbs_set_is_account_used(cbs, account_creator_is_account_used); + linphone_account_creator_cbs_set_create_account(cbs, account_creator_create_account); + linphone_account_creator_cbs_set_activate_account(cbs, account_creator_activate_account); + linphone_account_creator_cbs_set_link_phone_number_with_account(cbs, account_creator_link_phone_number_with_account); + linphone_account_creator_cbs_set_activate_phone_number_link(cbs, account_creator_activate_phone_number_link); + linphone_account_creator_cbs_set_is_account_activated(cbs, account_creator_is_account_activated); +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setUsername(JNIEnv *env, jobject thiz, jlong ptr, jstring jusername) { + const char *username = GetStringUTFChars(env, jusername); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_username(account_creator, username); + ReleaseStringUTFChars(env, jusername, username); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getUsername(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *username = linphone_account_creator_get_username(account_creator); + return username ? env->NewStringUTF(username) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setPhoneNumber(JNIEnv *env, jobject thiz, jlong ptr, jstring jphonenumber, jstring jcountrycode) { + const char *phone_number = GetStringUTFChars(env, jphonenumber); + const char *country_code = GetStringUTFChars(env, jcountrycode); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_phone_number(account_creator, phone_number, country_code); + ReleaseStringUTFChars(env, jphonenumber, phone_number); + ReleaseStringUTFChars(env, jcountrycode, country_code); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getPhoneNumber(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *phone_number = linphone_account_creator_get_phone_number(account_creator); + return phone_number ? env->NewStringUTF(phone_number) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setPassword(JNIEnv *env, jobject thiz, jlong ptr, jstring jpassword) { + const char *password = GetStringUTFChars(env, jpassword); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_password(account_creator, password); + ReleaseStringUTFChars(env, jpassword, password); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getPassword(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *password = linphone_account_creator_get_password(account_creator); + return password ? env->NewStringUTF(password) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setActivationCode(JNIEnv *env, jobject thiz, jlong ptr, jstring jcode) { + const char *activation_code = GetStringUTFChars(env, jcode); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_activation_code(account_creator, activation_code); + ReleaseStringUTFChars(env, jcode, activation_code); + return (jint) status; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setTransport(JNIEnv *env, jobject thiz, jlong ptr, jint jtransport) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_transport(account_creator, (LinphoneTransportType)jtransport); + return (jint) status; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_getTransport(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneTransportType transport = linphone_account_creator_get_transport(account_creator); + return (jint) transport; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setDomain(JNIEnv *env, jobject thiz, jlong ptr, jstring jdomain) { + const char *domain = GetStringUTFChars(env, jdomain); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_domain(account_creator, domain); + ReleaseStringUTFChars(env, jdomain, domain); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getDomain(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *domain = linphone_account_creator_get_domain(account_creator); + return domain ? env->NewStringUTF(domain) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setRoute(JNIEnv *env, jobject thiz, jlong ptr, jstring jroute) { + const char *route = GetStringUTFChars(env, jroute); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_route(account_creator, route); + ReleaseStringUTFChars(env, jroute, route); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getRoute(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *route = linphone_account_creator_get_route(account_creator); + return route ? env->NewStringUTF(route) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setDisplayName(JNIEnv *env, jobject thiz, jlong ptr, jstring jname) { + const char *name = GetStringUTFChars(env, jname); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_display_name(account_creator, name); + ReleaseStringUTFChars(env, jname, name); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getDisplayName(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *display_name = linphone_account_creator_get_display_name(account_creator); + return display_name ? env->NewStringUTF(display_name) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_setEmail(JNIEnv *env, jobject thiz, jlong ptr, jstring jemail) { + const char *email = GetStringUTFChars(env, jemail); + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneAccountCreatorStatus status = linphone_account_creator_set_email(account_creator, email); + ReleaseStringUTFChars(env, jemail, email); + return (jint) status; +} + +extern "C" jstring Java_org_linphone_core_LinphoneAccountCreatorImpl_getEmail(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + const char *email = linphone_account_creator_get_email(account_creator); + return email ? env->NewStringUTF(email) : NULL; +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_isAccountUsed(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + return (jint) linphone_account_creator_is_account_used(account_creator); +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_createAccount(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + return (jint) linphone_account_creator_create_account(account_creator); +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_activateAccount(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + return (jint) linphone_account_creator_activate_account(account_creator); +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_isAccountActivated(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + return (jint) linphone_account_creator_is_account_activated(account_creator); +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_linkPhoneNumberWithAccount(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + return (jint) linphone_account_creator_link_phone_number_with_account(account_creator); +} + +extern "C" jint Java_org_linphone_core_LinphoneAccountCreatorImpl_activatePhoneNumberLink(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + return (jint) linphone_account_creator_activate_phone_number_link(account_creator); +} + +extern "C" jobject Java_org_linphone_core_LinphoneAccountCreatorImpl_configure(JNIEnv *env, jobject thiz, jlong ptr) { + LinphoneAccountCreator *account_creator = (LinphoneAccountCreator *)ptr; + LinphoneProxyConfig *lpc = linphone_account_creator_configure(account_creator); + LinphoneCore *lc = account_creator->core; + LinphoneCoreVTable *table = linphone_core_get_current_vtable(lc); + LinphoneCoreData* lcData = (LinphoneCoreData*)linphone_core_v_table_get_user_data(table); + return getProxy(env, lpc, lcData->core); +} \ No newline at end of file diff --git a/coreapi/linphonecore_utils.h b/coreapi/linphonecore_utils.h index 6b199162c..6b66f37a4 100644 --- a/coreapi/linphonecore_utils.h +++ b/coreapi/linphonecore_utils.h @@ -117,7 +117,7 @@ LINPHONE_PUBLIC int linphone_dial_plan_lookup_ccc_from_e164(const char* e164); /** * Return NULL-terminated array of all known dial plans **/ -LINPHONE_PUBLIC const LinphoneDialPlan* linphone_dial_plan_get_all(); +LINPHONE_PUBLIC const LinphoneDialPlan* linphone_dial_plan_get_all(void); /** * Find best match for given CCC diff --git a/java/common/org/linphone/core/LinphoneAccountCreator.java b/java/common/org/linphone/core/LinphoneAccountCreator.java new file mode 100644 index 000000000..7888379ee --- /dev/null +++ b/java/common/org/linphone/core/LinphoneAccountCreator.java @@ -0,0 +1,136 @@ +/*LinphoneAccountCreator.java +Copyright (C) 2016 Belledonne Communications, Grenoble, France + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ +package org.linphone.core; + +import java.util.Vector; + +import org.linphone.core.LinphoneAddress.TransportType; + +public interface LinphoneAccountCreator { + interface LinphoneAccountCreatorListener { + void onAccountCreatorIsAccountUsed(LinphoneAccountCreator accountCreator, Status status); + void onAccountCreatorAccountCreated(LinphoneAccountCreator accountCreator, Status status); + void onAccountCreatorAccountActivated(LinphoneAccountCreator accountCreator, Status status); + void onAccountCreatorAccountLinkedWithPhoneNumber(LinphoneAccountCreator accountCreator, Status status); + void onAccountCreatorPhoneNumberLinkActivated(LinphoneAccountCreator accountCreator, Status status); + void onAccountCreatorIsAccountActivated(LinphoneAccountCreator accountCreator, Status status); + } + + public static class Status { + static private Vector values = new Vector(); + private final int mValue; + private final String mStringValue; + public final int value() { return mValue; } + + public final static Status Ok = new Status(0, "Ok"); + public final static Status Failed = new Status(1, "Failed"); + public final static Status AccountCreated = new Status(2, "AccountCreated"); + public final static Status AccountNotCreated = new Status(3, "AccountNotCreated"); + public final static Status AccountExist = new Status(4, "AccountExist"); + public final static Status AccountNotExist = new Status(5, "AccountNotExist"); + public final static Status AccountActivated = new Status(6, "AccountActivated"); + public final static Status AccountAlreadyActivated = new Status(7, "AccountAlreadyActivated"); + public final static Status AccountNotActivated = new Status(8, "AccountNotActivated"); + public final static Status EmailInvalid = new Status(9, "EmailInvalid"); + public final static Status UsernameInvalid = new Status(10, "UsernameInvalid"); + public final static Status UsernameTooShort = new Status(11, "UsernameTooShort"); + public final static Status UsernameTooLong = new Status(12, "UsernameTooLong"); + public final static Status UsernameInvalidSize = new Status(13, "UsernameInvalidSize"); + public final static Status PhoneNumberInvalid = new Status(14, "PhoneNumberInvalid"); + public final static Status PhoneNumberTooShort = new Status(15, "PhoneNumberTooShort"); + public final static Status PhoneNumberTooLong = new Status(16, "PhoneNumberTooLong"); + public final static Status PasswordTooShort = new Status(17, "PasswordTooShort"); + public final static Status PasswordTooLong = new Status(18, "PasswordTooLong"); + public final static Status DomainInvalid = new Status(19, "DomainInvalid"); + public final static Status RouteInvalid = new Status(20, "RouteInvalid"); + public final static Status DisplayNameInvalid = new Status(21, "DisplayNameInvalid"); + public final static Status TransportNotSupported = new Status(22, "TransportNotSupported"); + + private Status(int value, String stringValue) { + mValue = value; + values.addElement(this); + mStringValue = stringValue; + } + + public static Status fromInt(int value) { + for (int i=0; i < values.size(); i++) { + Status state = (Status) values.elementAt(i); + if (state.mValue == value) return state; + } + throw new RuntimeException("Status not found [" + value + "]"); + } + + public String toString() { + return mStringValue; + } + + public int toInt() { + return mValue; + } + } + + void setListener(LinphoneAccountCreatorListener listener); + + Status setUsername(String username); + + String getUsername(); + + Status setPhoneNumber(String phoneNumber, String countryCode); + + String getPhoneNumber(); + + Status setPassword(String password); + + String getPassword(); + + Status setActivationCode(String activationCode); + + Status setTransport(TransportType transport); + + TransportType getTransport(); + + Status setDomain(String domain); + + String getDomain(); + + Status setRoute(String route); + + String getRoute(); + + Status setDisplayName(String displayName); + + String getDisplayName(); + + Status setEmail(String email); + + String getEmail(); + + Status isAccountUsed(); + + Status createAccount(); + + Status activateAccount(); + + Status isAccountActivated(); + + Status linkPhoneNumberWithAccount(); + + Status activatePhoneNumberLink(); + + LinphoneProxyConfig configure(); +} diff --git a/java/impl/org/linphone/core/LinphoneAccountCreatorImpl.java b/java/impl/org/linphone/core/LinphoneAccountCreatorImpl.java new file mode 100644 index 000000000..1f5c4a840 --- /dev/null +++ b/java/impl/org/linphone/core/LinphoneAccountCreatorImpl.java @@ -0,0 +1,192 @@ +/*LinphoneAccountCreatorImpl.java +Copyright (C) 2016 Belledonne Communications, Grenoble, France + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ +package org.linphone.core; + +import org.linphone.core.LinphoneAddress.TransportType; + +public class LinphoneAccountCreatorImpl implements LinphoneAccountCreator { + protected long nativePtr; + + protected LinphoneAccountCreatorImpl(long aNativePtr) { + nativePtr = aNativePtr; + } + + private native long newLinphoneAccountCreator(long lc, String url); + public LinphoneAccountCreatorImpl(LinphoneCore lc, String url) { + nativePtr = newLinphoneAccountCreator(((LinphoneCoreImpl)lc).nativePtr, url); + } + + public long getNativePtr() { + return nativePtr; + } + + private native void unref(long ptr); + protected void finalize() { + unref(nativePtr); + } + + private native void setListener(long ptr, LinphoneAccountCreatorListener listener); + @Override + public void setListener(LinphoneAccountCreatorListener listener) { + setListener(nativePtr, listener); + } + + private native int setUsername(long ptr, String username); + @Override + public Status setUsername(String username) { + return Status.fromInt(setUsername(nativePtr, username)); + } + + private native String getUsername(long ptr); + @Override + public String getUsername() { + return getUsername(nativePtr); + } + + private native int setPhoneNumber(long ptr, String phoneNumber, String countryCode); + @Override + public Status setPhoneNumber(String phoneNumber, String countryCode) { + return Status.fromInt(setPhoneNumber(nativePtr, phoneNumber, countryCode)); + } + + private native String getPhoneNumber(long ptr); + @Override + public String getPhoneNumber() { + return getPhoneNumber(nativePtr); + } + + private native int setPassword(long ptr, String password); + @Override + public Status setPassword(String password) { + return Status.fromInt(setPassword(nativePtr, password)); + } + + private native String getPassword(long ptr); + @Override + public String getPassword() { + return getPassword(nativePtr); + } + + private native int setActivationCode(long ptr, String activationCode); + @Override + public Status setActivationCode(String activationCode) { + return Status.fromInt(setActivationCode(nativePtr, activationCode)); + } + + private native int setTransport(long ptr, int transport); + @Override + public Status setTransport(TransportType transport) { + return Status.fromInt(setTransport(nativePtr, transport.toInt())); + } + + private native int getTransport(long ptr); + @Override + public TransportType getTransport() { + return TransportType.fromInt(getTransport(nativePtr)); + } + + private native int setDomain(long ptr, String domain); + @Override + public Status setDomain(String domain) { + return Status.fromInt(setDomain(nativePtr, domain)); + } + + private native String getDomain(long ptr); + @Override + public String getDomain() { + return getDomain(nativePtr); + } + + private native int setRoute(long ptr, String route); + @Override + public Status setRoute(String route) { + return Status.fromInt(setRoute(nativePtr, route)); + } + + private native String getRoute(long ptr); + @Override + public String getRoute() { + return getRoute(nativePtr); + } + + private native int setDisplayName(long ptr, String displayName); + @Override + public Status setDisplayName(String displayName) { + return Status.fromInt(setDisplayName(nativePtr, displayName)); + } + + private native String getDisplayName(long ptr); + @Override + public String getDisplayName() { + return getDisplayName(nativePtr); + } + + private native int setEmail(long ptr, String email); + @Override + public Status setEmail(String email) { + return Status.fromInt(setEmail(nativePtr, email)); + } + + private native String getEmail(long ptr); + @Override + public String getEmail() { + return getEmail(nativePtr); + } + + private native int isAccountUsed(long ptr); + @Override + public Status isAccountUsed() { + return Status.fromInt(isAccountUsed(nativePtr)); + } + + private native int createAccount(long ptr); + @Override + public Status createAccount() { + return Status.fromInt(createAccount(nativePtr)); + } + + private native int activateAccount(long ptr); + @Override + public Status activateAccount() { + return Status.fromInt(activateAccount(nativePtr)); + } + + private native int linkPhoneNumberWithAccount(long ptr); + @Override + public Status isAccountActivated() { + return Status.fromInt(linkPhoneNumberWithAccount(nativePtr)); + } + + private native int isAccounlinkPhoneNumberWithAccounttUsed(long ptr); + @Override + public Status linkPhoneNumberWithAccount() { + return Status.fromInt(isAccounlinkPhoneNumberWithAccounttUsed(nativePtr)); + } + + private native int activatePhoneNumberLink(long ptr); + @Override + public Status activatePhoneNumberLink() { + return Status.fromInt(activatePhoneNumberLink(nativePtr)); + } + + private native LinphoneProxyConfig configure(long ptr); + @Override + public LinphoneProxyConfig configure() { + return configure(nativePtr); + } +}