Discussion :

[olibara]

Bonjour

Je n'ai aucune experience en Java mais j'aimerais un avis sur la possibilité d'interfacer une DLL ecrite en C avec Java

Pour information j'ai déja ecrit une interface en CSharp pour cette meme DLL

Cette DLL contient plusieurs fonctions des des parametre d'appel different mais les type principaux sont

string (char *)
int *
int

En Csharp je n'ai pas eu de difficulté majeure pour les le passage et retour de parametre mais j'ai du effectivement chipoter un peu

Je me demande si pour Java ce sera similaire ou si je m'attaque a la muraille de chine !

Merci de votre aide

[KindPlayer]

C'est tout à fait possible. Cela se fait via une JNI, java native interface qui établit entre autres les correspondances entre les types C/C++ et Java. Donc regarder des tuto sur la JNI.

[olibara]

Merci,

Je vais regarder de ce coté

Mais ton sentiment de base ?

Est-ce que cela risque d'etre beaucoup plus compliqué qu'avec Csharp ou bien c'est similaire ?

[adiGuba]

Salut,


Avec JNI tu devras passer par du code natif...
Sinon tu peux te tourner vers JNA, en particulier si ta DLL n'utilise pas de type exotique...

Tutoriel : Exécuter du code natif en Java : JNI VS JNA

a++

[olibara]

Salut

Qu'entends tu par "code natif" ?

E cSharp je n'ai pas eu besoin de transformer ma DLL

J'ai du adapter les déclarations des fonctions
Et j'ai ecrit une interface en Csharp qui permet d'appeller la dll via des methodes csharp
J'espere pouvoir faire la meme chose en java

Exemple des déclarations

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
using System.Runtime.InteropServices;
 
static public class Routing
  {
    [DllImport("bcta.Dll")]
    static public extern int bctaOpen(ref IntPtr hBcta, string a, char b);
    [DllImport("bcta.Dll")]
    static public extern int bctaGetTrack(IntPtr hBcta, PntF[] Pnt, int count);
    [DllImport("bcta.Dll")]
    static public extern int bctaSetName(IntPtr hBcta, string name);
    [DllImport("bcta.Dll")]
    static public extern void bctaClose(IntPtr hBcta);
    [DllImport("bcta.Dll")]
    static public extern int bctaSetAttribute(IntPtr hBcta, UInt32 nAttr, UInt32 nValue);
    [DllImport("bcta.Dll")]
    static public extern int bctaGetAttribute(IntPtr hBcta, UInt32 nAttID, ref UInt32 pAttr);
    [DllImport("bcta.Dll")]
    static public unsafe extern int bctaGetName(IntPtr hBcta, UInt32 nAttID, out IntPtr** StrPtr);
    [DllImport("bcta.Dll")]
    static public unsafe extern int bctaGetElemNodes(IntPtr hBcta, UInt32 nAttID, out PntF* PntPtr);
    [DllImport("bcta.Dll")]
    static public unsafe extern int bctaGetElemNodesAB(IntPtr hBcta, UInt32 ElemId, UInt32 *NodePtr);
    [DllImport("bcta.Dll")]
    static public unsafe extern int bctaGetElemByNodeA(IntPtr hBcta,UInt32 dsId, UInt32 NodeA, UInt32* SegPtr);
 
    [DllImport("bcta.Dll")]   // recherche d'elements proches d'un point
    static public unsafe extern int bctaGetElemsAt(IntPtr hBcta, ref PntF Pnt, UInt32 dist, UInt32 Mask, out UInt32 *SegPtr);
 
    [DllImport("bcta.Dll")]   // Get attribut d'un ID segment
    static public unsafe extern int bctaGetElemAtt(IntPtr hBcta, UInt32 Id, char b, ref UInt32 SegAttr);

[adiGuba]

Qu'entends tu par "code natif" ?

JNI nécessite que la DLL soit adapté à Java, et donc cela oblige à écrire une DLL wrapper, et donc à faire du code natif...




JNA permet quand à lui un mapping automatique des méthodes, en respectant un certain format (voir le tutoriel donnée plus haut)


a++