i have looked through all the other posts here about this subject but none of them helped me.
i am using a third party SDK (oovoo) and it contains a .jar file and .so file (armeabi-v7a)
as stated in allot of places, i put the .jar file in the libs folder and the armeabi-v7a folder (which contains the .so file) in a folder named jniLibs inside src/main
after building, when i unzip the .apk i see a folder named lib and inside it a folder named armeabi-v7a which contains the .so file
yet i still get this exception:
java.lang.UnsatisfiedLinkError: Native method not found: com.oovoo.core.ClientCore.VideoChannelPtr.nCreate:(Ljava/lang/String;)J
why cant it reach the implementation?
if it is in the lib folder in
the .apk does it mean it will for it at runtime?
thanks allot!
android studio version 0.8.6
gradle version 1.12
oovoo version 1.2.4
To answer your questions specifically :
It can't reach the implementation because at runtime, when the java environment tries to load a native method named java_com_oovoo_core_ClientCore_VideoChannelPtr_nCreate with the prototype int (string) it doesn't find such a method loaded. This can be caused by the following :
the .so library isn't loaded by the time you called that method , hence java doesn't know about it (so it's your mistake, you called the functions in wrong order)
the .so library doesn't export such a function, which means you have no chance of fixing this
the .so library loaded at runtime by the phone requires a different architecture besides armv7s. Be sure your device is armv7s.
the folder in which the Android system is looking for native libs is different than you expect. I know this was an old issue, so create in your apk, in your lib folder both "armeabi-v7a" and "armeabi" , and copy that .so file in both
Regarding your 2nd question, yes, if you have the lib inside the apk you will have it at runtime.
Related
I have an requirement which i have to build .so file using NDK build in Android and I have to call some of the methods from the .so file in my other Android application.
What I have tried so far.
I have taken the .so file from the lib folder of my Android project and put in my other application libs folder where I should call that .so file. I have used the below code:
Note: I am using ECLIPSE
static {
System.loadLibrary("NativeCode");
}
and also tried with full path of library
static {
System.loadLibrary("fullpath\NativeCode");
}
both the cases its giving unsatisfiedLinkError that mean it's not getting the path of my .so file.
You need to have your libNativeCode.so in the jni folder of your root, and not in the libs or lib folder
Here is a nice tutorial : http://www3.ntu.edu.sg/home/ehchua/programming/android/android_ndk.html
Alternatively, you can use following commands:
adb shell
$echo $PATH
What it will do is display a path like this :
/sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin
You can have your .so in any of these folders like /system, /system/bin, /system/sbin. (Remember, but you would need to manually copy it, and it is not a good idea to do so for an app)
Edit :
You can not call any JNI function in your app, because the signature. You need to have a JNI wrapper (a .so JNI lib that in turn uses the .h header file to call the JNI function of the other library). This is because JNI is very sensitive to signatures. So, as I recommended earlier, follow the tutorial !
In order to get your .so library to be loaded using loadLibrary() you'll have to copy the libNativeCode.so lib into the jniLibs/architecture folder.
The folder should be located under src/main/jniLibs/armeabi-v7a of your Android Application module (assuming you're using Android Studio).
After you copy the libraries, add the following line to your build.gradle located at the app module folder:
assert file("./src/main/jniLibs/armeabi-v7a/libNativeCode.so").exists()
After you'll complete the above steps it should load the lib properly.
If the libNativeCode.so is located at the wrong path, the Gradle build will fail.
Good luck,
Can someone guide me on the correct placement of where *.so files are supposed to be housed for a gradle/android project?
I have them in:
project->app->src->main->jniLibs
and the assets, java, and res folders are siblings to it in main as well but they don't seem to be included when the APK is built causing an 'UnsatisfiedLinkError'
EDIT
I have looked at:
Include .so library in apk in android studio
and have tried changing the director to both libs and lib with no luck.
UPDATE 1
The APK de-compiled now shows the *.so files under /Lib and I have them under project -> app -> src -> main -> jniLibs -> armeabi and that is their architecture but I am getting an UnsatisfiedLinkError when calling a method from within the native library although it seems to get past the System.loadLibrary call in the static constructor without showing an error
*.so files are included and shown in decompiled APK now...hitting another issue which I posted here: UnsatisfiedLinkError when calling method from native library although System.loadLibrary seems ok
I've made an android library project that uses some native libraries.
I've made the jni wrapper and put the native libs (.so) in the libs// folders. The native libs are compiled using cmake, for armeabi, armeabi-v7a, x86 and mips.
I export this project to a jar and put this jar into a "normal" android project. I then export this project to an apk and can see that my libs are bundles into it.
However, when i install the apk, the libs corresponding to the device are not copied into /data/data/com.my.app/lib and obviously, running the app complains about not finding the libs (UnsatisfiedLinkError).
I've search through SO and everywhere i can but found no answer that solved my case.
i'm using Eclipse, btw
Thanks for your help
UPDATE
OK, i've read the doc in the ndk and seen the examples, and unfortunately, i can't see the solution.
The ndk build the c code into shared libs and places them into the appropriated location in the project. But it doesn't generate anything that says that the libs must be installed with the apk.
My goal is to provide an android library (so a jar), that can be included within an android application. I don't see the real difference between what i'm doing (compile the c libs using cmake and package the jni and java compiled classes into a jar) and what is done with android.mk
If you see what i'm missing, feel free to tell me (even if its obvious).
thanks
UPDATE
i've made a dirty hack: in the libs folder of my application, i've put the jar file containing my classes and my native libs and a copy of the .so files for each arch. Suprise, the libs are no installed in /data/data/com.me.myapp/lib
It seems to confirm that it's a packaging problem.
I export this project to a jar and put this jar into a "normal"
android project. I then export this project to an apk and can see that
my libs are bundles into it.
The issue is that the Android packaging system doesn't handle with binary assets in JARs. For your application project to find and include the generated .so files, you need it to reference the library project as an 'Android library project':
Did you call ndk-build command?
See description below for details.
http://developer.android.com/tools/sdk/ndk/index.html
You can build the shared libraries for the sample apps by going into /samples// then calling the ndk-build command. The generated shared libraries will be located under /samples//libs/armeabi/ for (ARMv5TE machine code) and/or /samples//libs/armeabi-v7a/ for (ARMv7 machine code).
I have built a dynamic library in android using android build system. This library provides jni interface for functions inside it. Now I want to include this library in an application (.apk). I am using eclipse for application development. Now, how can I use the prebuild dynamice library (.so) in my application ? I tried putting it in a lib folder in my application but it is not working.
Any pointers are appreciated.
I am not using ndk to build my .so.
Since you write 'so' I think you're using NDK. If you're using NDK I don't know the answer.
If you're using the "Java" SDK, then in your library project go to Properties -> Android, and Check "Is Library". In your "apk" project, go to Properties -> Android -> Add . And your Library project should be available.
Also, any Library added in the "Java Build Path" Menu (again, in project properties) should be available in the APK in the end.
I know it's slightly old, but have you checked in the built APK to see if your .so library is there? Should be in the libs/armeabi folder.
Also, your .so file should be in lib/armeabi folder in your eclipse solution. I'm guessing the armeabi bit depends on which processor your .so file is build for.
Also, I know that if your library isn't called lib[name].so, it won't get copied when the apk is installed on the device. So:
libfoo.so copies
foo.so doesn't copy
foo.so doesn't copy
Also, you can use DDMS (its a view in eclipse) and it's file explorer to see if it's been copied to your device. It should be under data/data/[packagename]/lib.
Hope this helps a bit!
Andy.
I hit this same problem while building Qiqqa for Android. Under your eclipse android project, make sure you have a libs directory (not that it is plural libS not singular lib). Inside that create the armeabi/etc subdirs with their respectibe .so files.
Then when you build, eclipse will automatically pick up this libs directory and create the corresponding lib in your apk. System.loadLibrary("XXX") will then resolve to libXXX.so on your correct architecture...
Cheers,
Jimme
I am creating a widget that we will provide to developer end users and it consists of a .jar and a native library (.so) built using the NDK. The JAR has a JNI interface to the dynamic library.
It's very clear on how to include an external .jar in a project but not how to include a dependent dynamic library.
How do I package up and build the .jar and .so? What are the best practices here?
I can create the JAR file using the JDK's jar command. Do I need to run dx.bat on the jar to convert to Dalvik bytecode?
I need to create a sample project showing the widget in action. How do I include this .jar and .so in a sample project that demonstrates how to use the widget?
I spent some time on this, and i just can't understand why isn't this written on wikitude documentation.... anyway follow this changes!
go to windows/preferences/android/build
uncheck the first and the second option
extract files from wikitudesdk.jar with winrar as if it is an archive, search libarchitect.so and copy it in /libs/libs/armeabi/
add wikitudesdk.jar to your build path
You should use the standard build tools included with the SDK for this. If you include the .jar files you need in the /lib directory of your project, the ant build process will convert the included class files to Dalvik bytecode format and include them in your classes.dex file for the app. Add a build.properties file to your project root as well, with one line:
external.libs.dir=lib
Depending on the version of your SDK and configuration of it, you may need to place the jar in libs rather than lib.
As for the .so, I presume that it's properly compiled using the Android NDK, or using a build script that uses the proper compiler and compiler flags that are required to successfully link the shared object on Android. If this is the case, you can include the .so file in libs/armeabi and they will be added in the jar as well. Furthermore, the dynamic library loader will know to look in this location in the .jar when you actually try to load the library from Java code.
Using ADT 12, I accomplished this by doing the following:
1) Export JAR from your library with the SO file using Eclipse. Make sure you exclude AndroidManifest.xml. This will include source code and other data, so if you are distributing, you'll want to strip these unnecessary bits out using any ZIP utility.
2) Create a directory in your App's source tree (I use "lib" directory) and copy your library JAR to it.
3) Right-click project in Eclipse and select "Configure Build Path". Add JAR and point it to JAR inside your App source tree.
4) In your Eclipse preferences, select Android/Build section and uncheck "Automatically refresh Resources and Assets folder on build". You will notice an option below that says "Force error when external jars contain native libraries." There is an ADT bug, which will supposedly be fixed in R17, which uses the wrong setting. Once it is fixed, you will use the "Force error" one (make sure it unchecked).
5) Once you build your app APK, you will have a libs/armeabi/libXXXX.so file. This will not be automatically unpacked on install. You will need to write code to extract it from your APK file into your data directory, then use System.load on the .so file in your data directory.
I have bidirectional JNI calls going from the dynamically loaded file, and even use dlopen() on it to do my custom plugin registration stuff.
Add the below lines to android.mk.
include $(BUILD_PACKAGE)
LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := alias:libs/your.jar
include $(BUILD_MULTI_PREBUILT)