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
