1
votes

Ajouter une nouvelle fonction native à linphone avec le nouveau wrapper java

Ajout d'une fonction personnalisée au nouveau SDK linphone.

Comme les développeurs ont guidé, j'ai construit liblinphone android sdk en ajoutant une petite fonction au code C bellesip. Ajout d'une entrée associée à linphonecore_jni.cc et compilation de linphone-android-sdk. Sur la page de documentation, il est indiqué que le wrapper sera généré automatiquement pour les fonctions natives. Mais après avoir construit AAR et ajouté cela au projet linphone, je ne peux pas voir ma méthode dans les méthodes Core. J'ai essayé à la fois -DENABLE_JAVA_WRAPPER=NO et - DENABLE_JAVA_WRAPPER=YES .

J'ai essayé d'ajouter

JNIEXPORT void JNICALL Java_org_linphone_core_LinphoneCoreImpl_setCutomFunction(JNIEnv *env, jobject thiz, jlong lc, jint tik, jint tik_size) {
    settiks(tiks, tik_size);

}linphonecore_jni

Je m'attendais à ce que je puisse appeler la méthode native dans le code java linphone. Toutes les méthodes sont remplies à l'exception de ma méthode personnalisée dans le noyau. Y a-t-il une étape supplémentaire en dehors de l'ajout du fichier de bibliothèque linphonesdk AAR au projet linphone.

java-native-interface linphone linphone-sdk jniwrapper

1 commentaires

Avez-vous réussi à résoudre ce problème?

3 Réponses :

0
votes

Pour pouvoir générer automatiquement un wrapper JNI pour la fonction C, vous devez l'inclure dans le projet linphone et non dans belle-sip.

assurez-vous qu'il est correctement documenté selon la norme doxygen dans un fichier d'en-tête de la bibliothèque linphone.

0 commentaires

0
votes

Je pense que nous devrions utiliser le nouveau wrapper comme recommandation des développeurs Linphone.

Tous les fichiers comme Core.java, linphone_jni.cc ... seront automatiquement générés lors de la construction de linphonesdk. Les règles de génération sont définies par des fichiers .mustache si je comprends bien.

Les anciens fichiers comme linphonecore_jni.cc, LinphoneCore.java ne sont plus utilisés. Vous modifiez peut-être ces anciens fichiers.

Dans les anciennes versions, vos nouvelles méthodes sont générées dans Core.java, linphone_jni.cc ... vous devez les ajouter dans les bons fichiers .c et .h, avec le bon format et les bonnes annotations.

Par exemple: je souhaite ajouter la méthode ci-dessous dans Core.java:

cmake --build .

cartographie avec la méthode

LinphoneCall * linphone_core_invite_address_to_conference_with_params(LinphoneCore *lc, const LinphoneAddress *addr, LinphoneCallParams *params) {
    // Add your code here
    return /* return what you want */;
}

dans linphone_jni.cc

Tout ce que j'ai à faire est d'ajouter linphone / include / linphone / core.h:

/**
 * Some texts
 *
 * @param[in] lc #LinphoneCore object
 * @param[in] addr The destination of the call (sip address).
 * @param[in] params Call parameters
 * @return A #LinphoneCall object or NULL in case of failure
 * @ingroup call_control */
LINPHONE_PUBLIC LinphoneCall * linphone_core_invite_address_to_conference_with_params(LinphoneCore *lc, const LinphoneAddress *addr, LinphoneCallParams *params);

Et dans linphonecore.c:

JNIEXPORT jobject JNICALL Java_org_linphone_core_CoreImpl_createConferenceWithParams(JNIEnv *env, jobject thiz, jlong ptr, jobject params)

Puis construisez le linphonesdk en:

Call inviteAddressToConferenceWithParams(Address var1, CallParams var2);

Après cela, tout le code associé dans Core.java, linphone_jni.cc sera généré. Faites attention aux annotations. Sans eux, le code ne sera pas généré.

0 commentaires

0
votes

Je montre un exemple pour ajouter une nouvelle fonction dans Call.Java dans le fichier .aar, car le fichier linphonecore_jni.cc n'est plus utilisé dans la nouvelle version de Linphone.

Ouvrez le fichier ci-dessous:

public boolean testfunction();

ajouter une nouvelle déclaration de fonction:

JNIEXPORT jboolean JNICALL Java_org_linphone_core_CallImpl_testfunction(JNIEnv *env, jobject thiz, jlong ptr, jboolean enable) {
        LinphoneCall *cptr = (LinphoneCall*)ptr;

        if (cptr == nullptr) {
                bctbx_error("Java_org_linphone_core_CallImpl_testfunction's LinphoneCall C ptr is null!");
                return 0;
        }

        jboolean jni_result = (jboolean)linphone_call_testfunction(cptr, (bool_t)enable));
        return jni_result;
}

Maintenant, ouvrez le fichier ci-dessous:

bool_t linphone_call_testfunction (const LinphoneCall *call, bool_t enable) {
        return Call::toCpp(call)->testFunction();
}

Ajoutez une nouvelle définition de fonction dans le fichier:

liblinphone/src/c-wrapper/api/c-call.cpp

Maintenant, il va générer build / WORK / android-armv7 / Build / linphone / wrappers / java / src / linphone_jni.cc avec la fonction ci-dessous:

/**
 * Enables or disable echo cancellation for this call
 * @param call the #LinphoneCall object @notnil
 * @param enable wether to enable some functionality or not.
**/
LINPHONE_PUBLIC void linphone_call_testfunction(LinphoneCall *call, bool_t enable);

Et maintenant, assurez-vous qu'un autre fichier généré build / WORK / android-armv7 / Build / linphone / wrappers / java / java / org / linphone / core / Call.java avec déclaration de fonction:

liblinphone/include/linphone/api/c-call.h

Maintenant, pour appeler cette fonction dans le code Java, copiez le dernier fichier .aar dans le projet linphone-android dans android studio. Faites un clic droit sur le projet-> Recharger à partir du disque puis essayez d'accéder à la fonction. Cette procédure a parfaitement fonctionné pour moi.

0 commentaires