Android Intent传递Parcelable和Serializable对象原理分析

Android Intent传递Parcelable和Serializable对象原理分析

　　当我们需要打开一个Activity的时候，经常使用Intent去传递一些数据给将要打开的Activity。这些数据类型中经常会包含类类型，但是不能什么类都可以通过Intent传递的，必须是实现了Parcelable或者Serializable接口才行。如：

实现Serializeble例子

public class Person implements Serializable{
    private static final long serialVersionUID = 7382351359868556980L;
    private String name;
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

实现Parcelable例子

public class Pen implements Parcelable{
    private String color;
    private int size;
    protected Pen(Parcel in) {
        color = in.readString();
        size = in.readInt();
    }
    public static final Creator<Pen> CREATOR = new Creator<Pen>() {
        @Override
        public Pen createFromParcel(Parcel in) {
            return new Pen(in);
        }
        @Override
        public Pen[] newArray(int size) {
            return new Pen[size];
        }
    };
    @Override
    public int describeContents() {
        return 0;
    }
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(color);
        dest.writeInt(size);
    }
}

那么问题来了，那为什么需要实现这两个接口呢？实现的接口又是怎么被调用的呢？

启动一个Activity并且传递对象给启动的Activity

Intent intent = new Intent(getActivity(), NewActivity.class);
intent.putExtra("person", new Person());    // #1
intent.putExtra("person", new Pen());    // #2
startActivity(intent);

Intent.putExtra()有很多个重写的方法，#1处会调用

//Intent.java
    public Intent putExtra(String name, Serializable value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putSerializable(name, value);
        return this;
    }

#2处会调用

//Intent.java
public Intent putExtra(String name, Parcelable value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putParcelable(name, value);
        return this;
    }

可以看到两个方法其实内容差不多，分别主要调用了mExtras.putSerializable和mExtras.putParcelable，只要分析一个方法，另外的一个也就清楚了，所以后面只跟踪分析Parcelable，最后在看Serializable的实现。

在Intent中mExtras是一个Bundle类，接着分析mExtras.putParcelable()方法

//Bunder.java
    public void putParcelable(@Nullable String key, @Nullable Parcelable value) {
        unparcel();    //初始化容器 
        mMap.put(key, value);    //将 key 和 value 存放在 ArrayMap 成员变量中
        mFdsKnown = false;
    }

将对象值保存在Intent后，接着会调用Activity.startActivity( Intent )方法，将Intent的保存的值传递给打开的Activity去。我们知道调用Activity.startActivity方法会调用Context的实现类ComtextImpl的startActivity方法，如下：

//ContextImpl.java
@Override
public void startActivity(Intent intent) {
    if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
        throw new AndroidRuntimeException(
                "Calling startActivity() from outside of an Activity "
                + " context requires the FLAG_ACTIVITY_NEW_TASK flag."
                + " Is this really what you want?");
    }
    mMainThread.getInstrumentation().execStartActivity(
        getOuterContext(), mMainThread.getApplicationThread(), null, null, intent, -1);
}

上面的方法主要调用了 mMainThread.getInstrumentation().execStartActivity，这个方法最终会调用ActivityManagerService的代理类ActivityManagerProxy类的startActivity()。如果不清楚这一过程的可以参考Android应用程序启动过程源代码分析，这里不是我们的重点。

//ActivityManagerProxy.java
public int startActivity(IApplicationThread caller, Intent intent,
        String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
        IBinder resultTo, String resultWho,
        int requestCode, boolean onlyIfNeeded,
        boolean debug) throws RemoteException {
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeInterfaceToken(IActivityManager.descriptor);
    data.writeStrongBinder(caller != null ? caller.asBinder() : null);
    intent.writeToParcel(data, 0);    //#1 
    data.writeString(resolvedType);
    data.writeTypedArray(grantedUriPermissions, 0);
    data.writeInt(grantedMode);
    data.writeStrongBinder(resultTo);
    data.writeString(resultWho);
    data.writeInt(requestCode);
    data.writeInt(onlyIfNeeded ? 1 : 0);
    data.writeInt(debug ? 1 : 0);
    mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
    reply.readException();
    int result = reply.readInt();
    reply.recycle();
    data.recycle();
    return result;
}

这个方法的参数Intent还是我们自己new出来的那个Intent对象。这个有关这个参数的就只有#1 intent.writeToParcel(data, 0);具体调用如下：

//Intent.java
public void writeToParcel(Parcel out, int flags) {
    out.writeString(mAction);
    Uri.writeToParcel(out, mData);
    out.writeString(mType);
    out.writeInt(mFlags);
    out.writeString(mPackage);
   //...
    out.writeInt(mContentUserHint);
    out.writeBundle(mExtras);    //#1 将mExtras里面的内容写入out对象里
}

可以看到最后#1使用到了mExtras，这个参数是我们前面提到了Bundle类型的Intent成员变量，当时我们的对象就是保存在这个里面的。接着玩下看

//Parcel.java
public final void writeBundle(Bundle val) {
    if (val == null) {
        writeInt(-1);
        return;
    }
    val.writeToParcel(this, 0);//#1 
}

#1调用了Bundle.writeToParcel，将Bundle里面的内容写入out对象里

//Bundle.java
/**
 * Writes the Bundle contents to a Parcel, typically in order for
 * it to be passed through an IBinder connection.
 * @param parcel The parcel to copy this bundle to.
 */
@Override
public void writeToParcel(Parcel parcel, int flags) {
    final boolean oldAllowFds = parcel.pushAllowFds((mFlags & FLAG_ALLOW_FDS) != 0);
    try {
        super.writeToParcelInner(parcel, flags); //#1
    } finally {
        parcel.restoreAllowFds(oldAllowFds);
    }
}

上面的方法又会调用super.writeToParcelInner，即调用Bundle父类BaseBundle的writeToParcelInner方法

//BaseBundle.java
/**
 * Writes the Bundle contents to a Parcel, typically in order for
 * it to be passed through an IBinder connection.
 * @param parcel The parcel to copy this bundle to.
 */
void writeToParcelInner(Parcel parcel, int flags) {
    // Keep implementation in sync with writeToParcel() in
    // frameworks/native/libs/binder/PersistableBundle.cpp.
    final Parcel parcelledData;
    synchronized (this) {
        parcelledData = mParcelledData;
    }
    if (parcelledData != null) {
        if (isEmptyParcel()) {
            parcel.writeInt(0);
        } else {
            int length = parcelledData.dataSize();
            parcel.writeInt(length);
            parcel.writeInt(BUNDLE_MAGIC);
            parcel.appendFrom(parcelledData, 0, length);
        }
    } else {
        // Special case for empty bundles.
        if (mMap == null || mMap.size() <= 0) {
            parcel.writeInt(0);
            return;
        }
        int lengthPos = parcel.dataPosition();
        parcel.writeInt(-1); // dummy, will hold length
        parcel.writeInt(BUNDLE_MAGIC);

        int startPos = parcel.dataPosition();
        parcel.writeArrayMapInternal(mMap); //#1
        int endPos = parcel.dataPosition();

        // Backpatch length
        parcel.setDataPosition(lengthPos);
        int length = endPos - startPos;
        parcel.writeInt(length);
        parcel.setDataPosition(endPos);
    }
}

可以看到这个方法会调用#1 parcel.writeArrayMapInternal(mMap);这里的mMap很眼熟，我们之前的就是把将要传递的对象保存以key/value的形式保存在这个里面的。接着往下看

//Parcel.java
/**
 * Flatten an ArrayMap into the parcel at the current dataPosition(),
 * growing dataCapacity() if needed.  The Map keys must be String objects.
 */
void writeArrayMapInternal(ArrayMap<String, Object> val) {
    if (val == null) {
        writeInt(-1);
        return;
    }
    // Keep the format of this Parcel in sync with writeToParcelInner() in
    // frameworks/native/libs/binder/PersistableBundle.cpp.
    final int N = val.size();
    writeInt(N);
    //...
    int startPos;
    for (int i=0; i<N; i++) {
        if (DEBUG_ARRAY_MAP) startPos = dataPosition();
        writeString(val.keyAt(i));    //#1
        writeValue(val.valueAt(i));    //#2
       //...
    }
}

这个方法主要调用了#1，#2两行代码，就是将ArrayMap<String, Object>类型的实例val所保存的数据一一取出来然后依次保存在当前的Parcel对象里面。最重要的是#2 writeValue(val.valueAt(i));,这里就是要取出我们保存在Intent里面的Parcelable或者Serializable对象了。接着往下看

//Parcel.java
public final void writeValue(Object v) {
    if (v == null) {
        writeInt(VAL_NULL);
    } else if (v instanceof String) {
        writeInt(VAL_STRING);
        writeString((String) v);
    } else if (v instanceof Integer) {
        writeInt(VAL_INTEGER);
        writeInt((Integer) v);
    } else if (v instanceof Map) {
        writeInt(VAL_MAP);
        writeMap((Map) v);
    } else if (v instanceof Bundle) {
        // Must be before Parcelable
        writeInt(VAL_BUNDLE);
        writeBundle((Bundle) v);
    } else if (v instanceof PersistableBundle) {
        writeInt(VAL_PERSISTABLEBUNDLE);
        writePersistableBundle((PersistableBundle) v);
    } else if (v instanceof Parcelable) {
        // IMPOTANT: cases for classes that implement Parcelable must
        // come before the Parcelable case, so that their specific VAL_*
        // types will be written.
        writeInt(VAL_PARCELABLE);
        writeParcelable((Parcelable) v, 0);    //#1
    } else if (v instanceof Short) {
        writeInt(VAL_SHORT);
        writeInt(((Short) v).intValue());
    } else if (v instanceof Long) {
        writeInt(VAL_LONG);
        writeLong((Long) v);
    } else if (v instanceof Float) {
        writeInt(VAL_FLOAT);
        writeFloat((Float) v);
    } else if (v instanceof Double) {
        writeInt(VAL_DOUBLE);
        writeDouble((Double) v);
    } else if (v instanceof Boolean) {
        writeInt(VAL_BOOLEAN);
        writeInt((Boolean) v ? 1 : 0);
    } else if (v instanceof CharSequence) {
        // Must be after String
        writeInt(VAL_CHARSEQUENCE);
        writeCharSequence((CharSequence) v);
    } else if (v instanceof List) {
        writeInt(VAL_LIST);
        writeList((List) v);
    } else if (v instanceof SparseArray) {
        writeInt(VAL_SPARSEARRAY);
        writeSparseArray((SparseArray) v);
    } else if (v instanceof boolean[]) {
        writeInt(VAL_BOOLEANARRAY);
        writeBooleanArray((boolean[]) v);
    } else if (v instanceof byte[]) {
        writeInt(VAL_BYTEARRAY);
        writeByteArray((byte[]) v);
    } else if (v instanceof String[]) {
        writeInt(VAL_STRINGARRAY);
        writeStringArray((String[]) v);
    } else if (v instanceof CharSequence[]) {
        // Must be after String[] and before Object[]
        writeInt(VAL_CHARSEQUENCEARRAY);
        writeCharSequenceArray((CharSequence[]) v);
    } else if (v instanceof IBinder) {
        writeInt(VAL_IBINDER);
        writeStrongBinder((IBinder) v);
    } else if (v instanceof Parcelable[]) {
        writeInt(VAL_PARCELABLEARRAY);
        writeParcelableArray((Parcelable[]) v, 0);
    } else if (v instanceof int[]) {
        writeInt(VAL_INTARRAY);
        writeIntArray((int[]) v);
    } else if (v instanceof long[]) {
        writeInt(VAL_LONGARRAY);
        writeLongArray((long[]) v);
    } else if (v instanceof Byte) {
        writeInt(VAL_BYTE);
        writeInt((Byte) v);
    } else if (v instanceof Size) {
        writeInt(VAL_SIZE);
        writeSize((Size) v);
    } else if (v instanceof SizeF) {
        writeInt(VAL_SIZEF);
        writeSizeF((SizeF) v);
    } else if (v instanceof double[]) {
        writeInt(VAL_DOUBLEARRAY);
        writeDoubleArray((double[]) v);
    } else {
        Class<?> clazz = v.getClass();
        if (clazz.isArray() && clazz.getComponentType() == Object.class) {
            // Only pure Object[] are written here, Other arrays of non-primitive types are
            // handled by serialization as this does not record the component type.
            writeInt(VAL_OBJECTARRAY);
            writeArray((Object[]) v);
        } else if (v instanceof Serializable) {
            // Must be last
            writeInt(VAL_SERIALIZABLE);
            writeSerializable((Serializable) v);    //#2
        } else {
            throw new RuntimeException("Parcel: unable to marshal value " + v);
        }
    }
}

注意查看#1,#2两处代码，这里分别先将Object类型v强制转换为Parcelable和Serializable接口，将Parcelable和Serializable对象写入到当前的对象里面。

//Parcel.java
    public final void writeParcelable(Parcelable p, int parcelableFlags) {
        if (p == null) {
            writeString(null);
            return;
        }
        writeParcelableCreator(p);    //保存类名
        p.writeToParcel(this, parcelableFlags);    //#1
    }

#1最终调用Parcelable接口的writeToParcel方法，这里就会调用我们前面Pen类实现的writeToParcel方法，即：

//Pen.java
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(color);
        dest.writeInt(size);
    }

将当前类各个成员的值写入到dest对象里面。
同样的writeSerializable方法最终会调用Java自带的序列化类ObjectOutputStream来序列话Serializable对象，将其转化为字节数组保存到Parcel里面。

/**
 * Write a generic serializable object in to a Parcel.  It is strongly
 * recommended that this method be avoided, since the serialization
 * overhead is extremely large, and this approach will be much slower than
 * using the other approaches to writing data in to a Parcel.
 */
public final void writeSerializable(Serializable s) {
    if (s == null) {
        writeString(null);
        return;
    }
    String name = s.getClass().getName();
    writeString(name);

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(s);
        oos.close();

        writeByteArray(baos.toByteArray());
    } catch (IOException ioe) {
        throw new RuntimeException("Parcelable encountered " +
            "IOException writing serializable object (name = " + name +
            ")", ioe);
    }
}

到这里，系统将需要传递给要打开的Activity的数据打包到Parcel里面去了，接着会将这个包裹传递给Binder驱动。
当一个Activity构造出来之后又会调用

//Parcel.java
    public final <T> T readTypedObject(Parcelable.Creator<T> c) {
        if (readInt() != 0) {
            return c.createFromParcel(this);
        } else {
            return null;
        }
    }

接着调用到Pen的CREATOR对象的createFromParcel，生成一个对象：

//Pen.java
 protected Pen(Parcel in) {
        color = in.readString();
        size = in.readInt();
    }
    public static final Creator<Pen> CREATOR = new Creator<Pen>() {
        @Override
        public Pen createFromParcel(Parcel in) {
            return new Pen(in);
        }
        @Override
        public Pen[] newArray(int size) {
            return new Pen[size];
        }
    };

最终组装的这个对象会传递给Activity.

总的来说，两个Activity通过Intent传递一个对象的过程，就是将对象每一个成员变量的值保存到Parcel中，传递给Binder驱动，然后再将Parcel组装起来，形成一个对象，然后提供给另一个Activity用。