JNI调用NFIQ库C++方法，求std::list<NFIQ::QualityFeatureSpeed>&的Java等效参数

Great question! Handling C++ std::list references in JNI can feel tricky at first, but it’s all about bridging C++’s standard containers with Java’s collection types. Let’s walk through exactly what you need to do for that std::list<NFIQ::QualityFeatureSpeed> & parameter.

First, your Java code should use a java.util.List<QualityFeatureSpeed> (or a concrete implementation like ArrayList<QualityFeatureSpeed>) as the equivalent for std::list<NFIQ::QualityFeatureSpeed> &.

Why? Because std::list is an ordered, mutable collection, which aligns perfectly with Java’s List interface. Since the C++ parameter is a reference (&), the native function will populate the list with data—so you’ll pass an empty, modifiable List instance from Java, and the JNI wrapper will fill it with converted data after calling computeQualityScore.

First step: Create a Java class that mirrors the NFIQ::QualityFeatureSpeed C++ struct. For example, if the C++ struct looks like this:

namespace NFIQ {
    struct QualityFeatureSpeed {
        std::string featureId;
        unsigned long elapsedTimeMs;
        // Other fields specific to your NFIQ implementation
    };
}

Your Java QualityFeatureSpeed class would look like this:

public class QualityFeatureSpeed {
    private String featureId;
    private long elapsedTimeMs;

    // Constructor matching the struct's fields
    public QualityFeatureSpeed(String featureId, long elapsedTimeMs) {
        this.featureId = featureId;
        this.elapsedTimeMs = elapsedTimeMs;
    }

    // Optional getters if you need to access the data in Java
    public String getFeatureId() { return featureId; }
    public long getElapsedTimeMs() { return elapsedTimeMs; }
}

Next, let’s outline how to handle the parameter in your JNI function. Here’s a step-by-step breakdown of the code:

1. Java Native Method Signature #

Your Java native method declaration will look like this (adjust package/class names to match your codebase):

public native int computeQualityScore(
    FingerprintImageData rawImage,
    boolean computeActionableQuality,
    List<ActionableQualityFeedback> actionableQuality,
    boolean outputFeatures,
    List<QualityFeatureData> qualityFeatureData,
    boolean outputSpeed,
    List<QualityFeatureSpeed> qualityFeatureSpeed
);

(Note: You’ll need to create matching Java classes for ActionableQualityFeedback and QualityFeatureData too, following the same pattern as QualityFeatureSpeed.)

2. JNI Function Logic #

In your C++ JNI wrapper, you’ll:

• Create empty C++ lists to pass as references to computeQualityScore
• Call the native NFIQ function
• Convert each element in the populated C++ list to a Java object
• Add those objects to the Java List passed from the caller

Here’s the code snippet:

#include <jni.h>
#include <list>
#include "NFIQ.h" // Include your NFIQ library header

// Helper function to convert Java FingerprintImageData to C++ NFIQ::FingerprintImageData
// Implement this based on how your FingerprintImageData struct is structured
NFIQ::FingerprintImageData convertJavaFingerprintToNative(JNIEnv* env, jobject javaImage);

JNIEXPORT jint JNICALL Java_com_yourpackage_YourWrapperClass_computeQualityScore(
    JNIEnv* env,
    jobject thisObj,
    jobject rawImage,
    jboolean bComputeActionableQuality,
    jobject actionableQualityList,
    jboolean bOutputFeatures,
    jobject qualityFeatureDataList,
    jboolean bOutputSpeed,
    jobject qualityFeatureSpeedList
) {
    // Step 1: Prepare empty C++ lists for output parameters
    std::list<NFIQ::ActionableQualityFeedback> actionableFeedback;
    std::list<NFIQ::QualityFeatureData> featureData;
    std::list<NFIQ::QualityFeatureSpeed> speedData;

    // Step 2: Convert Java FingerprintImageData to native C++ type
    NFIQ::FingerprintImageData nativeRawImage = convertJavaFingerprintToNative(env, rawImage);

    // Step 3: Call the NFIQ computeQualityScore function
    unsigned int score = NFIQ::computeQualityScore(
        nativeRawImage,
        static_cast<bool>(bComputeActionableQuality),
        actionableFeedback,
        static_cast<bool>(bOutputFeatures),
        featureData,
        static_cast<bool>(bOutputSpeed),
        speedData
    );

    // Step 4: Populate the Java List with QualityFeatureSpeed data (if output is enabled)
    if (bOutputSpeed && qualityFeatureSpeedList != nullptr) {
        // Get references to Java List methods
        jclass listClass = env->GetObjectClass(qualityFeatureSpeedList);
        jmethodID listAddMethod = env->GetMethodID(listClass, "add", "(Ljava/lang/Object;)Z");
        if (listAddMethod == nullptr) {
            env->ThrowNew(env->FindClass("java/lang/RuntimeException"), "Failed to access List.add() method");
            return score;
        }

        // Get reference to QualityFeatureSpeed constructor
        jclass speedClass = env->FindClass("com/yourpackage/QualityFeatureSpeed");
        jmethodID speedConstructor = env->GetMethodID(speedClass, "<init>", "(Ljava/lang/String;J)V");
        if (speedConstructor == nullptr) {
            env->ThrowNew(env->FindClass("java/lang/RuntimeException"), "Failed to find QualityFeatureSpeed constructor");
            env->DeleteLocalRef(listClass);
            return score;
        }

        // Iterate over C++ list and convert each element to Java
        for (const auto& speedItem : speedData) {
            // Convert C++ types to JNI-compatible types
            jstring featureIdJStr = env->NewStringUTF(speedItem.featureId.c_str());
            jlong elapsedTimeJ = static_cast<jlong>(speedItem.elapsedTimeMs);

            // Create Java QualityFeatureSpeed object
            jobject javaSpeedObj = env->NewObject(speedClass, speedConstructor, featureIdJStr, elapsedTimeJ);

            // Add object to the Java List
            env->CallBooleanMethod(qualityFeatureSpeedList, listAddMethod, javaSpeedObj);

            // Clean up local references to avoid memory leaks
            env->DeleteLocalRef(featureIdJStr);
            env->DeleteLocalRef(javaSpeedObj);
        }

        // Clean up remaining local references
        env->DeleteLocalRef(listClass);
        env->DeleteLocalRef(speedClass);
    }

    // Repeat the above conversion logic for actionableQualityList and qualityFeatureDataList if needed

    return static_cast<jint>(score);
}

• Error Handling: Always check if jmethodID or jclass values are nullptr—throw a Java exception if they are to avoid silent crashes.
• Local References: JNI local references (like jobject, jclass) consume memory, so always call DeleteLocalRef when you’re done with them.
• Type Conversion: Double-check that you’re converting C++ types to the correct JNI equivalents (e.g., unsigned long → jlong, std::string → jstring).
• Reusability: The same pattern applies to the other std::list parameters—just create matching Java classes and repeat the conversion logic.

内容的提问来源于stack exchange，提问作者sindhu