NDK-Samples | Collection of Code Samples to be used with the Native SDK | SDK library

I am trying to interface with an MSI SDR dongle, using an android app

This device is a clone of the SDRPlay SDR device, and is compatible with it's software and drivers

I am trying to interface with this using an OTG cable and android phone

The android drivers for this can be downloaded from here https://www.sdrplay.com/downloads/

It is in the Android tab under the API/HW – V2.11 (15TH NOV 2017) link (https://www.sdrplay.com/anddl.php)

A possible sample code for this driver can be found here: https://www.sdrplay.com/docs/AndroidIntegrationNote.pdf

Before making the full android program it says the library (libmir_sdr_api.a) should be built into an .so library file using ndk-build

I currently have Android's hello-jni sample project from here: https://github.com/android/ndk-samples/tree/android-mk/hello-jni

I have replaced the jni folder using the Android.mk file, libmir_sdr_api.a, mir_sdr.h, initialization-jni.cpp, demod-jni.cpp and demod-jni.h files mentioned in section 3 of the AndroidIntegrationNote.pdf file I linked above

When I execute ndk-build from the hello-jni project folder, I get he following error:

I have import and tested this project:

https://github.com/android/ndk-samples/tree/master/hello-jni

in Android Studio and worked well.

But when I copy the code for another new project I have the follow error:

“Incompatible point types jclass and `jobject”

In this line:

I'm using Android NDK and need access to assets. A requirement for asset access seems to be obtaining an AssetManager reference.

Looking at the NDK samples (https://github.com/android/ndk-samples), the pattern seems to be:

• A JNIEnv* is passed into the func when called directly from the JavaVM, along with some jobject
• Use these to get AAssetManager* and then use this to open assets

That seems simple enough, except in my case, the functions are being called from Unity so I don't have access to either a JNIEnv* or jobject. Getting the JNIEnv* seems easy enough as I can make use of JNI_OnLoad to get access to a JavaVM* and then use that to get a JNIEnv* via vm->GetEnv. My questions about this are:

1) My understanding is that, an Android app can only have one instance of a Java VM. Am I safe to take the JavaVM* passed into JNI_OnLoad and save it for use in other function calls?

2) What about the JNIEnv*? Can I grab that once during JNI_OnLoad and save it, or should I grab a fresh one every time I need to use assets within a function? Is JNIEnv* something I need to explicitly free? (i.e. what's the lifetime/ownership situation with JNIEnv*?)

3) AAssetManager_fromJava also requires a jobject with the documentation (https://developer.android.com/ndk/reference/group/asset#group___asset_1gadfd6537af41577735bcaee52120127f4) saying: "Note that the caller is responsible for obtaining and holding a VM reference to the jobject to prevent its being garbage collected while the native object is in use.". I've seem some examples that simply pass in an empty (native) string like AAssetManager_fromJava(env, ""); - is that ok? I'd only be using the AssetManager for the lifetime of that call, and I could get a fresh one each time. (Again, is AAssetManager* a resource I need to manage, or am I just getting a reference to something owned elsewhere? The documentation seems to imply the latter.)

4) So given all the above, I'd probably do something like: