nazareno - ¿Cómo puedo mapear los siguientes elementos de una Estructura en C a Java?

jni nazareno

Question

Tengo la siguiente Estructura en C que necesita asignarse a Java. Porque necesito llamar a un método desde una DLL generada desde el código C. La siguiente es mi estructura.

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;

El IPJ_READER_CONTEXT y IPJ_READER_IDENTIFIER se ve a continuación.

typedef void* IPJ_READER_CONTEXT;
typedef void* IPJ_READER_IDENTIFIER;

¿Cómo puedo analizar esos dos elementos para mapear a Java? Por favor aconséjame.

Answer 1

Aah después de una larga búsqueda aquí uno interesado en OOP vs paradigma funcional. Entonces aquí podemos resolverlo. Aquí van los pasos básicos.

• Nombra tu estructura como una clase.

• Pon todos los atributos de la estructura como atributos de clase.

• Para esos vacíos *, en java puede usar variables de referencia.

• luego, para una instancia de estructura, ya que tienes estructura con el nombre de ipj_iri_device, simplemente crea un objeto de la clase nombrada en la viñeta uno.

  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 
   }

Answer 2

Aquí hay un ejemplo de cómo se vería su estructura usando 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];
}

Puede definir las estructuras que respaldan los campos reader_context y reader_identifier si necesita sus contenidos. Si no, puedes pasarlos como un Pointer genérico.

EDITAR

Estas estructuras se pueden usar independientemente del resto de JNA, todo lo que necesita es una representación del Pointer de la memoria nativa para mover los datos hacia adelante y hacia atrás.

Answer 3

Puede usar JNIWrapper para asignar su estructura C a Java y llamar a la función desde DLL.

El contenedor para la estructura dada se verá como se muestra a continuación (los valores para las constantes de tamaño deben cambiarse):

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;
    }
}

Si necesita un puntero a la instancia de la estructura, debe crear la instancia de la clase Pointer:

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

Después de eso, puede usar la instancia del puntero para pasar el parámetro de la función. El siguiente código muestra cómo cargar la biblioteca y llamar a la función desde allí:

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

Si la estructura se modifica después de la llamada, todos los cambios estarán disponibles en el objeto structureInstance.

Como puede ver, en este caso no necesita escribir ningún código nativo adicional.

Puede encontrar más detalles sobre el uso de JNIWrapper en su guía de programador . Además, existe el foro JNIWrapper que contiene respuestas a muchas preguntas populares.