ashmem | using ashmem in Android Applications | Android library

At the end of your log, just before the initial crash. there is a warning:

Default FirebaseApp failed to initialize because no default options were found. This usually means that com.google.gms:google-services was not applied to your gradle project.

simply adding com.google.gms:google-services should fix any issues you have, if you have issues, ensure your Gradle cache is cleared or run without the build cache --no-build-cache

I am answering my own question

I just found a temporary solution but failed to find what is happening inside retrofit and android and why

OK, after 4 days, my resolver was change my assembly name from mixed lowercase and upercase to lowercase and every think work fine to this time.

As you can see in the dmesg output:

[ 5.379690] usb 1-1: New USB device found, idVendor=10c4, idProduct=ea60

Looking that up, e.g. here: https://www.google.com/search?q=usb%20vendor%20id%2010c4

Tells you that it's a "Silicon Labs" USB device, who also make the CP2102.

The log does not identify other devices (ignore the linux kernel root hub). So either you have also a CP2102 attached (and the FTDI is not properly connected) or the device you think is a FTDI based device, is not.

In addition you can identify currently enumerated devices using the lsusb command.

The automatic loading is usually done by udev or a similar user space daemon/mechanism. A decent explanation can be found e.g. here: https://lwn.net/Articles/740455/

It seems to be a tensorflow-lite library internal problem. Your code seems to work fine as the following statement is recorded in the log: "succed to build FirebaseModelInterpreter", which means that onSuccessListener has worked fine. The problem occurs afterwards when tensorflow lite runtime is being initialized and the error is a libc error, which seems to have originated at the OS level, apparently due to some illegal memory access. In my assessment, this can only be due to tensorflow-lite library itself. You may try with a different version of the library or a different device, but I can't say anything for sure.

In gradle file:

Try changing

implementation 'org.tensorflow:tensorflow-lite:2.0.0'

to

implementation 'org.tensorflow:tensorflow-lite:+'

Firebaser here-

It looks like this crash report you've pasted a screenshot for is occurring in system libraries only. We can see that in the Crashlytics crash report (and the tombstone) that all the stackframes are associated with "libc.so" - this is an Android system runtime library, and any libraries like those Crashlytics is unable to symbolicate.

This is because Crashlytics can only symbolicate crashes or stackframes that come from libraries that you've uploaded symbols for. And since libc.so is a system library for which both you and Crashlytics both don't have the symbols for, this is expected behavior. Crashlytics still shows the frames even though it can't symbolicate just so that it's still reporting as much info as possible.

If you're able to submit a test crash report that has a callstack that goes through your own native libraries for which you're attempting to upload symbols, and you're still seeing "(Missing)" everywhere, that would be unexpected. If that's the case, I recommend making sure you've followed these instructions in the doc you linked, and reaching out to Firebase support if you're still having issues.

your observable should subscribed on background thread for doing a network call. in RxJava you can use subscribeOn(Schedulers.io()). that means your observable will be subscribed on io schedulers. io schedulers is commonly used when you are doing a network call operation

In your androidManifest.xml try this :

You only need /dev/ashmem to share memory between processes. NDK and SDK (Java/Kotlin) work in same Linux process and have full access to same memory space.

The usual way to define memory that can be used both from C++ and Java is by creating a Direct ByteBuffer. You don't need JNI for that, Java API has ByteBuffer.allocateDirect(int capacity). If it's more natural for your logical flow to allocate the buffer on the C++ side, JNI has the NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) function that you used in your question.

Working with Direct ByteBuffer is very easy on the C++ side, but not so efficient on the JVM side. The reason is that this buffer is not backed by array, and the only API you have involves ByteBuffer.get() with typed variations (getting byte array, char, int, …). You have control of current position in the buffer, but working this way requires certain discipline: every get() operation updates the current position. Also, random access to this buffer is rather slow, because it involves calling both positioning and get APIs. Therefore, in some cases of non-trivial data structures, it may be easier to write your custom access code in C++ and have 'intelligent' getters called through JNI.

It's important not to forget to set ByteBuffer.order(ByteOrder.nativeOrder()). The order of a newly-created byte buffer is counterintuitively BIG_ENDIAN. This applies both to buffer created from Java and from C++.

If you can isolate the instances when C++ needs access to such shared memory, and don't really need it to be pinned all the time, it's worth to consider working with byte array. In Java, you have more efficient random access. On the NDK side, you will call GetByteArrayElements() or GetPrimitiveArrayCritical(). The latter is more efficient, but its use imposes restrictions on what Java functions you can call until the array is released. On Android, both methods don't involve memory allocation and copy (with no official guarantee, though). Even though C++ side uses the same memory as Java, your JNI code must call the appropriate Release…() function, and better do that as early as possible. It's a good practice to handle this Get/Release via RAII.