JNI 基礎 - Android 共享內存的序列化過程

1. 進程間的通訊方式有哪些

2. binder 和 socket 通訊的區別有哪些

3. Android 爲何在大部分場景下用 Binder 進行進程間通訊

4. Serializable 和 Parcelable 之間的區別

5. Parcelable 序列化和反序列化的具體過程

不知道你們在面試中的過程當中，有沒有碰到上面相似的問題，我在騰訊和 oppo 面試的時候就碰到了，這些問題可能都比較簡單。好比：Serializable 開銷大，Parcelable 更加高效，可是若要問爲何是這樣？恐怕就會有一小部分人答不上來了。今天咱們就帶你們來了解這些知識，既然學了一些 JNI 基礎，那麼咱們本身從 native 層來實現這些。

以前講 opencv 有說到，能夠用純 java 代碼去寫，在 opencv 中 native 層操做的是 Mat 數據矩陣，對應 java 層也有 Mat 這個類，咱們看下 java 和 native 是怎麼對應起來的。

// C++: class Mat
//javadoc: Mat
public class Mat {

    public final long nativeObj;

    public Mat(long addr)
    {
        if (addr == 0)
            throw new java.lang.UnsupportedOperationException("Native object address is NULL");
        nativeObj = addr;
    }

    //
    // C++: Mat::Mat()
    //
    // javadoc: Mat::Mat()
    public Mat()
    {
        nativeObj = n_Mat();
        return;
    }

    //
    // C++: Mat::Mat(int rows, int cols, int type)
    //
    // javadoc: Mat::Mat(rows, cols, type)
    public Mat(int rows, int cols, int type)
    {
        // 在 c++ 層建立一個對象，而後把指針地址 jlong 返回給 java 層
        nativeObj = n_Mat(rows, cols, type); 
        return;
    }

    // C++: Mat::Mat()
    private static native long n_Mat();

    // C++: Mat::Mat(int rows, int cols, int type)
    private static native long n_Mat(int rows, int cols, int type);
}
複製代碼

JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__DDI
  (JNIEnv* env, jclass, jdouble size_width, jdouble size_height, jint type)
{
    static const char method_name[] = "Mat::n_1Mat__DDI()";
    try {
        LOGD("%s", method_name);
        Size size((int)size_width, (int)size_height);
        return (jlong) new Mat( size, type );
    } catch(const std::exception &e) {
        throwJavaException(env, &e, method_name);
    } catch (...) {
        throwJavaException(env, 0, method_name);
    }

    return 0;
}
複製代碼

上面的代碼比較簡單，當咱們調用 Mat mat = new Mat(720,1280,CvType.CV_8UC4) ，這個時候會調用 native 層去建立 c++ 的 Mat 對象，而後將指針地址回調給 java 層，爲何要這麼作？其實咱們也能猜到，c++ 操做的是 native 層的 Mat 的對象，咱們把建立好的對象指針給 java 層，是爲了再次在 native 層操做的時候，能夠根據指針地址找到對應 c++ 的 Mat 對象，而後就能夠進行一些列的操做。

爲何講到 opencv 去了？其實此次的重點就是，在 JNI 的開發過程當中，native 層的對象怎麼傳給 java 層的對象進行保存和操做。接下來咱們再來看一個例子 Android 共享內存的序列化過程，相信只要看過 Parcel 的源碼，上面的全部問題都迎刃而解了。若是沒有 frameworker 層的源碼，請先去下載，千萬不要下載閹割版的，裏面要有 native 層的源碼。

public final class Parcel {
    // 保存的是 c++ 層的 Parcel.cpp 對象的指針地址
    private long mNativePtr; // used by native code

    private Parcel(long nativePtr) {
        if (DEBUG_RECYCLE) {
            mStack = new RuntimeException();
        }
        //Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack);
        init(nativePtr);
    }

    private void init(long nativePtr) {
        if (nativePtr != 0) {
            mNativePtr = nativePtr;
            mOwnsNativeParcelObject = false;
        } else {
            mNativePtr = nativeCreate();
            mOwnsNativeParcelObject = true;
        }
    }

    /**
     * Write an integer value into the parcel at the current dataPosition(),
     * growing dataCapacity() if needed.
     */
    public final void writeInt(int val) {
        nativeWriteInt(mNativePtr, val);
    }

    /**
     * Read an integer value from the parcel at the current dataPosition().
     */
    public final int readInt() {
        return nativeReadInt(mNativePtr);
    }
    // 建立 Parcel.cpp 返回 jlong
    private static native long nativeCreate();
    // 寫入 int 數據
    private static native void nativeWriteInt(long nativePtr, int val);
    // 讀 int 數據
    private static native int nativeReadInt(long nativePtr);
}
複製代碼

// 建立 Parcel ，返回指針地址給 java 層
static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
{
    Parcel* parcel = new Parcel();
    return reinterpret_cast<jlong>(parcel);
}
// 經過指針地址獲取 c++ 層的對象，而後進行操做
static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) {
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    if (parcel != NULL) {
        const status_t err = parcel->writeInt32(val);
        if (err != NO_ERROR) {
            signalExceptionForError(env, clazz, err);
        }
    }
}
複製代碼

status_t Parcel::writeInt32(int32_t val)
{
    return writeAligned(val);
}

template<class T>
status_t Parcel::writeAligned(T val) {
    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE_UNSAFE(sizeof(T)) == sizeof(T));
    // 判斷大小有沒有超過
    if ((mDataPos+sizeof(val)) <= mDataCapacity) {
restart_write:
        // 往內存上寫入數據
        *reinterpret_cast<T*>(mData+mDataPos) = val;
        // 返回寫入成功
        return finishWrite(sizeof(val));
    }
    // 返回錯誤
    status_t err = growData(sizeof(val));
    if (err == NO_ERROR) goto restart_write;
    return err;
}

int32_t Parcel::readInt32() const
{
    return readAligned<int32_t>();
}

template<class T>
T Parcel::readAligned() const {
    T result;
    if (readAligned(&result) != NO_ERROR) {
        result = 0;
    }
    return result;
}

template<class T>
status_t Parcel::readAligned(T *pArg) const {
    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE_UNSAFE(sizeof(T)) == sizeof(T));
    // 有沒有超出
    if ((mDataPos+sizeof(T)) <= mDataSize) {
        // 去除當前內存上的值
        const void* data = mData+mDataPos;
        // 當前累加日後邏動
        mDataPos += sizeof(T);
        // 取出來並賦值
        *pArg =  *reinterpret_cast<const T*>(data);
        return NO_ERROR;
    } else {
        return NOT_ENOUGH_DATA;
    }
}
複製代碼

看到這裏再來講共享內存，或者說 binder 驅動就會變得簡單起來了，Parcel 其實就是在 native 層開闢了一塊內存，而後按照必定的順序往這塊內存裏面寫數據。當我須要取數據的時候，咱們按照原來寫的順序取出來就能夠了。寫的順序和取的順序必須保持一致，否則確定會出錯。那爲何不在 java 層作呢？請問在 java 層能作到這些效果嗎？這也證明了其實 c 和 c++ 更加靈活，由於操做的是一塊內存地址上的數據，想幹嗎就能夠幹嗎。怎麼回答上面的問題應該不用我說了，瞭解了原理那麼在回答的時候能夠本身作一些擴展。

既然是 JNI 基礎部分，那麼咱們最好仍是本身動手來敲一下。比如要了解 Retrofit 、OkHttp 和 RxJava 這些經常使用開源庫，咱們最好本身動手敲一下核心部分，就能更加加深印象。

var parcel = Parcel.obtain()

  parcel.writeInt(12)
  parcel.writeInt(24)

  var number1 = parcel.readInt()
  var number2 = parcel.readInt()

  Log.e("TAG","number1 = $number1 , number2 = $number2")
複製代碼

class Parcel{
    private var mNativePtr: Long = 0 // used by native code
    init {
        System.loadLibrary("native-lib")
        mNativePtr = nativeCreate();
    }
    private external fun nativeCreate(): Long;

    // 兩個讀寫 int 的方法
    fun writeInt(value: Int) {
        nativeWriteInt(mNativePtr, value);
    }
    fun readInt(): Any {
        return nativeReadInt(mNativePtr)
    }
    // 兩個讀寫 native 方法
    private external fun nativeWriteInt(mNativePtr: Long, value: Int);
    private external fun nativeReadInt(nativePtr: Long): Int
}
複製代碼

視頻地址：https://pan.baidu.com/s/1H2d3mxxZJn7brGEYKNrCHw 視頻密碼：i81c