5

我有以下需要映射到 Java 的 C 结构。因为我需要从 C 代码生成的 DLL 中调用一个方法。以下是我的结构。

typedef struct _ipj_iri_device
{
IPJ_READER_CONTEXT    reader_context;
IPJ_READER_IDENTIFIER reader_identifier;
uint32_t              receive_timeout_ms;

/* Internal Only */
uint8_t               sync_state;
bool                  wait_for_response;
uint32_t              frame_length;
uint32_t              receive_index;
uint8_t               receive_buffer[IPJ_RECEIVE_BUFFER_SIZE];

#if !defined(IRI_RX_ONLY)
uint8_t               transmit_buffer[IPJ_TRANSMIT_BUFFER_SIZE];
#endif

} ipj_iri_device;

IPJ_READER_CONTEXT 和 IPJ_READER_IDENTIFIER 如下所示。

typedef void* IPJ_READER_CONTEXT;
typedef void* IPJ_READER_IDENTIFIER;

如何解析这两个元素以映射到 Java？请指教。

4

3 回答 3

0

您可以使用JNIWrapper将您的 C 结构映射到 Java 并从 DLL 调用该函数。

给定结构的包装器如下所示（需要更改大小常量的值）：

import com.jniwrapper.*;

public class IpjIriDevice extends Structure
{
    private static final int IPJ_RECEIVE_BUFFER_SIZE = 0;
    private static final int IPJ_TRANSMIT_BUFFER_SIZE = 0;

    private Pointer.Void reader_context = new Pointer.Void();
    private Pointer.Void reader_identifier = new Pointer.Void();
    private UInt32 receive_timeout_ms = new UInt32();
    private UInt8 sync_state = new UInt8();
    private Bool wait_for_response = new Bool();
    private UInt32 frame_length = new UInt32();
    private UInt32 receive_index = new UInt32();
    private PrimitiveArray receive_buffer = new PrimitiveArray(UInt8.class, IPJ_RECEIVE_BUFFER_SIZE);
    private PrimitiveArray transmit_buffer = new PrimitiveArray(UInt8.class, IPJ_TRANSMIT_BUFFER_SIZE);

    public IpjIriDevice()
    {
        init(new Parameter[] {
            reader_context,  
            reader_identifier,  
            receive_timeout_ms,  
            sync_state,  
            wait_for_response,  
            frame_length,  
            receive_index,  
            receive_buffer,  
            transmit_buffer
        });
    }

    public long getReaderContext()
    {
        return reader_context.getValue();
    }

    public long getReaderIdentifier()
    {
        return reader_identifier.getValue();
    }

    public long getReceiveTimeoutMs()
    {
        return receive_timeout_ms.getValue();
    }

    public void setReceiveTimeoutMs(long value)
    {
        receive_timeout_ms.setValue(value);
    }

    public long getSyncState()
    {
        return sync_state.getValue();
    }

    public void setSyncState(long value)
    {
        sync_state.setValue(value);
    }

    public boolean getWaitForResponse()
    {
        return wait_for_response.getValue();
    }

    public void setWaitForResponse(boolean value)
    {
        wait_for_response.setValue(value);
    }

    public long getFrameLength()
    {
        return frame_length.getValue();
    }

    public void setFrameLength(long value)
    {
        frame_length.setValue(value);
    }

    public long getReceiveIndex()
    {
        return receive_index.getValue();
    }

    public void setReceiveIndex(long value)
    {
        receive_index.setValue(value);
    }

    public PrimitiveArray getReceiveBuffer()
    {
        return receive_buffer;
    }

    public PrimitiveArray getTransmitBuffer()
    {
        return transmit_buffer;
    }

    public Object clone()
    {
        IpjIriDevice result = new IpjIriDevice();
        result.initFrom(this);
        return result;
    }
}

如果需要指向结构实例的指针，则应创建 Pointer 类实例：

IpjIriDevice structureInstance = new IpjIriDevice();
Pointer structurePtr = new Pointer(structureInstance);

之后，您可以使用指针实例来传递函数参数。以下代码演示了如何加载库并从中调用函数： 

DefaultLibraryLoader.getInstance().addPath(LIB_PATH);
Library library = new Library(LIB_NAME);
Function function = library.getFunction(FUNCTION_NAME);
long errorCode = function.invoke(returnValue, structurePtr);

如果在调用后修改了结构，则所有更改都将在 structureInstance 对象中可用。

如您所见，在这种情况下，您不需要编写任何额外的本机代码。

您可以在其程序员指南中找到有关使用 JNIWrapper 的更多详细信息。此外，还有JNIWrapper 论坛，其中包含许多热门问题的答案。

于 2015-11-09T10:10:32.387 回答
0

Here's an example of what your structure might look like using JNA:

public class ipj_iri_device extends Structure {
    Pointer               reader_context;
    Pointer               reader_identifier;
    int                   receive_timeout_ms;
    /* Internal Only */
    byte                  sync_state;
    // field size depends on size of 'bool'; "byte" is usually correct
    byte                  wait_for_response; 
    int                   frame_length;
    int                   receive_index;
    byte[]                receive_buffer = new byte[IPJ_RECEIVE_BUFFER_SIZE];
    // may or may not be used, check your native compile flag
    byte[]                transmit_buffer = new byte[IPJ_TRANSMIT_BUFFER_SIZE];
}

You can define the structures backing the reader_context and reader_identifier fields if you need their contents. If not, you can just pass them around as a generic Pointer.

EDIT

These structures may be used independently of the rest of JNA, all you need is a Pointer representation of the native memory to move data back and forth.

于 2015-11-06T16:15:18.187 回答
-1

啊，经过长时间的搜索，这里对 OOP 与功能范式感兴趣。所以在这里我们可以像这样解决它。这里是基本步骤。

  • 将您的 Structure 命名为 class 。

  • 将结构的所有属性作为类属性。

  • 对于那些 void * ，在java中你可以使用引用变量。

  • 然后对于一个结构实例，当你得到一个名为 ipj_iri_device 的结构时，只需创建一个项目符号中命名的类的对象。

    public class _ipj_iri_device{
     int IPJ_RECEIVE_BUFFER_SIZE ;
     //get a value from whereever the input is coming ,assign it to buffersize
     IPJ_READER_CONTEXT    reader_context;
     IPJ_READER_IDENTIFIER reader_identifier;
     boolean wait_for_response;
     uint32_t receive_timeout_ms;
     //here uint32_t is a type  i asumed .You will have to define it explicitly

    //rest of the vaariables / members of structure 
 }
于 2015-11-06T07:47:00.403 回答