Activity 组件启动，Intent 类携带目标组件类信息，组件间传递的数据。
Intent intent = new Intent(this，XxxActivity.class);
intent.putExtra(key,value);
Bundle bundle = new Bundle();
bundle.putInt(key,value);
bundle.putString(key,value);
intent.putExtras(bundle);
startActivity(intent);
复杂类型必须实现 Parcelable 或 Serializable 接口。
一、数据结构
Intent 类，继承 Parcelable，支持序列化，适合进程间通信。
private String mAction;
private Uri mData;
private String mType;
private String mPackage;
private ComponentName mComponent;
private int mFlags;
private ArraySet mCategories;
private Bundle mExtras;
...
Intent 内部数据，包括 mAction mData mPackage 等系统数据及 Bundle mExtras 自定义数据。
向 Intent 写入 自定义数据。
Intent 的 putExtra()方法，将 key-value 写入内部 Bundle mExtras，简单或复杂类型，(如 int，short，float，String，Parcelable，Serializable)
public Intent putExtra(String name, int value) {
//mExtras是内部Bundle。
if (mExtras == null) {
mExtras = new Bundle();
}
mExtras.putInt(name, value);
return this;
}
putExtras() 方法，写入 Bundle 数据
public @NonNull Intent putExtras(@NonNull Bundle extras) {
if (mExtras == null) {
mExtras = new Bundle();
}
mExtras.putAll(extras);
return this;
}
将 Bundle 参数中的存储内容合并。
Bundle 内部 ArrayMap 数据结构存储。
ArrayMap mMap = null;
public void putInt(String key, int value) {
unparcel();
mMap.put(key, value);
}
Bundle 继承 BaseBundle 类，putInt() 方法，是父类的方法。
Bundle 和 BaseBundle 相关方法。
public void putParcelable(String key, Parcelable value)
public void putSerializable(String key, Serializable value)
public void putShort(String key, short value)
public void putFloat(String key, float value)
public void putChar(String key, char value)
public void putShortArray(String key, short[] value)
...
ArrayMap 类存储 key-value，Bundle 的 putParcelable() 方法。
public void putParcelable(String key, Parcelable value) {
unparcel();
mMap.put(key, value);
mFdsKnown = false;
}
所有数据都是在 ArrayMap 数据结构存储。
二、Intent 数据写入 Parcel
Activity 组件间跳转时，Intent 数据通过 Parcel 在进程间通信。
IActivityManager 的 startActivity() 方法，向 system_service 进程 Ams 服务发送请求。
public int startActivity(IApplicationThread caller, String callingPackage, ..) {
//Parcel池中获取两个Parcel对象
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
...
data.writeString(callingPackage);
//用于写入自己传递的数据
intent.writeToParcel(data, 0);
data.writeStrongBinder(resultTo);
....//写入数据到data后，远程通信
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
Parcel 写入数据，系统参数 resolvedType ，callingPackage 等，(String、int、Binder类型)
根据不同类型，Parcel 类的 writeXxx() 相关方法。
Intent writeToParcel() 方法，内部数据写入。
public void writeToParcel(Parcel out, int flags) {
//向Parcel写入Intent中的其他数据，如mAction字符串，mType、mFlags等
...
//App组件间传递自定义数据封装在Bundle中。
out.writeBundle(mExtras);
}
将 Intent 内部 mAction，mFlags ，Bundle mExtras 数据 写入 Parcel 。
对于 Bundle mExtras 数据。Parcel 类 writeBundle() 方法。
public final void writeBundle(Bundle val) {
if (val == null) {
writeInt(-1);
return;
}
val.writeToParcel(this, 0);
}
Bundle writeToParcel() 方法。
void writeArrayMapInternal(ArrayMap val) {
final int N = val.size();
...
for (int i=0; i 将 ArrayMap 每项数据，包括 key 和 value。writeValue() 方法，根据 Object，类型，选择不同的写入方法，
关于 Bundle 中复杂 Parcelable 数据类型，写入 Parcel
参考 Android Parcelable
三、Intent 初始化
在 onCreate() 方法启动时，getIntent() 获取的 Intent 初始化时机。
Ams 服务进程通过 ApplicationThreadProxy 代理回调 App 进程时，App进程将调用ApplicationThreadNative的onTransact方法，它继承Binder。
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:
//创建Intent。
Intent intent = Intent.CREATOR.createFromParcel(data);
IBinder b = data.readStrongBinder();
int ident = data.readInt();
ActivityInfo info = ActivityInfo.CREATOR.createFromParcel(data);
...
//该方法在ActivityThread中定义的ApplicationThread实体实现。
scheduleLaunchActivity(intent, b, ident, info, ....);
return true;
}
}
Binder的#execTransact方法，创建两个Parcel对象，在参数data中，已经保存了Ams进程传递的数据。
Intent 实现 Parcelable 接口，通过内部 CREATOR，创建一个新 Intent 对象。
因此，在Ams进程回调App，App启动组件生命周期前已经创建Intent，在ApplicationThread的#scheduleLaunchActivity方法，传给App主线程。
public static final Parcelable.Creator CREATOR
= new Parcelable.Creator() {
public Intent createFromParcel(Parcel in) {
return new Intent(in);
}
};
Intent 构造方法
protected Intent(Parcel in) {
readFromParcel(in);
}
提取 Parcel 中的 Intent 字段。
public void readFromParcel(Parcel in) {
setAction(in.readString());
mType = in.readString();//从Parcel解析数据到Intent内部
mFlags = in.readInt();
mPackage = in.readString();
...
mExtras = in.readBundle();//App组件间传递自定义数据
}
根据不同类型，Parcel 类 readXxx() 方法，解析数据向新 Intent 赋值。
Parcel readBundle()方法，解析 Intent Bundle mExtras 数据。
参考 Parcel 解析 Bundle 数据
Intent 构建完毕。
四、Intent 数据读取
Activity 组件启动，在 onCreate() 方法，Intent 类 getXxx() 方法，获取自定义数据。
getIntent().getStringExtra(key);
getIntent().getIntExtra(key,defaultValue);
getIntent().getParcelableExtra(key);
从 Intent 内部 Bundle 获取数据。
Intent 类 getParcelableExtra()方法，获取 XxxBean 实例。
public T getParcelableExtra(String name) {
return mExtras == null ? null : mExtras.getParcelable(name);
}
Bundle getParcelable() 方法，从 ArrayMap 读取。
public T getParcelable(@Nullable String key) {
unparcel();//解析底层Parcel数据，写入Map
Object o = mMap.get(key);
try {
return (T) o;
} catch (ClassCastException e) {
typeWarning(key, o, "Parcelable", e);
return null;
}
从 ArrayMap 读取前，先调用一次 unparcel() 方法，
将 Bundle 内 Parcel 数据初始化到 ArrayMap ，否则 ArrayMap 数据是空的。
参考 Parcel 解析 Bundle 数据
五、总结
1，通过Intent在组件间传递的数据，保存在Intent内部#Bundle的ArrayMap结构。本质，数据写入Parcel，跨进程传递类型，数据在底层Parcel保存。
2，Intent#writeToParcel方法，将Intent到系统数据和我们的自定义数据，全部写入Parcel，自定义数据时，遍历ArrayMap，将key和value写入Parcel。
3，Parcelable类型数据传递，本质，写入String类型的key，再将实体每个字段，根据类型对应writeXxx方法，依次写入。
4，Intent实现Parcelable接口，Ams服务回调App进程时，组件生命周期前，新建，从Parcel读取初始化内部变量如mFlags，readBundle方法创建内部Bundle，将Parcel设置内部即mParcelledData，此时不解析，在读取数据时，Bundle的#unparcel方法，将解析它。
5，从Parcel读取自定义数据到ArrayMap时，先读取String的key值，再从Parcel读取int类型type，简单类型通过JNI#方法直接读取内容，复杂类型如Parcelable，将利用实体内部的静态内部类CREATOR创建实例，依次读取Parcel中该实体字段。
6，Activity组件启动#onCreate方法，通过getIntent方法，获取的Intent和发起者组件在startActivity方法传入的是两个完全不同到对象，Activity组件实例化后，attach方法赋值，即mIntent。
任重而道远