共计 6152 个字符,预计需要花费 16 分钟才能阅读完成。
Activity 详解
什么是 Activity
Activity 是一个 Android 的利用组件,它提供屏幕进行交互。每个 Activity 都会取得一个用于绘制其用户界面的窗口,窗口能够充斥哦屏幕也能够小于屏幕并浮动在其余窗口之上。
一个利用通常是由多个彼此涣散分割的 Activity 组成,个别会指定利用中的某个 Activity 为主流动,也就是说首次启动利用时给用户出现的 Activity。将 Activity 设为主流动的办法,如上面代码所示须要在 AndroidManifest 文件中增加以下内容
<application>
....
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
....
</application>
当然 Activity 之间能够进行相互跳转,以便执行不同的操作。每当新 Activity 启动时,旧的 Activity 便会进行,然而零碎会在堆栈也就是返回栈中保留该 Activity。当新 Activity 启动时,零碎也会将其推送到返回栈上,并获得用户的操作焦点。当用户实现以后 Activity 并按返回按钮是,零碎就会从堆栈将其弹出销毁,而后回复前一 Activity
当一个 Activity 因某个新 Activity 启动而进行时,零碎会通过该 Activity 的生命周期回调办法告诉其这一状态的变动。Activity 因状态变动每个变动可能有若干种,每一种回调都会提供执行与该状态相应的特定操作的机会
Activity 对象的创立
Activity 的启动是一个跨过程通信的过程,对客户端而言,Activity 的创立会回调到ActivityThread 中的 handleLaunchActivity()
办法:
_frameworks/base/core/java/android/app/ActivityThread.java_:
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent){
···
final Activity a = performLaunchActivity(r, customIntent);
···
return a;
}
接着在 performLaunchActivity()
办法里找到了 Acitivity 实例的创立:
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
···
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
// 注解 1:通过 ClassLoader 以及指标 Activity 的类名来创立新的 Activity 实例
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
···
} ···
}
Activity 相干的创立工作交由给了 Instrumentation 类解决:
_frameworks/base/core/java/android/app/Instrumentation.java_:
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {String pkg = intent != null && intent.getComponent() != null
? intent.getComponent().getPackageName() : null;
return getFactory(pkg).instantiateActivity(cl, className, intent);
}
最终的创立工作由进一步交由工厂类 AppComponentFactory 实现:
_frameworks/base/core/java/android/app/AppComponentFactory.java_:
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
@Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {return (Activity) cl.loadClass(className).newInstance();}
到这里,Activity 对象的创立过程曾经很清晰了:通过 ClassLoader 对象以及类名获取到指标 Activity 的 Class 对象,再调用 Class 对象的 ****newInstance()
办法创立了实例。
用图形关系示意如下:
Activity 对象的援用关系
在分明了 Activity 对象的创立过程后,让咱们回到一开始的 ActivityThread 的performLaunchActivity()
办法中,接着往下看:
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
···
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
···
try {Application app = r.packageInfo.makeApplication(false, mInstrumentation);
···
if (activity != null) {
···
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback,
r.assistToken);
···
// 注解 2:ActivityClientRecord 对象持有 Activity 实例的援用
r.activity = activity;
}
r.setState(ON_CREATE);
// 注解 3:将 ActivityClientRecord 对象增加到 mActivities 汇合中
synchronized (mResourcesManager) {mActivities.put(r.token, r);
}
} ···
return activity;
}
在这里,咱们仿佛找到了想要的答案:
新建的 Activity 对象会被传进来的 ActivityClientRecord 对象所持有,接着该 ActivityClientRecord 对象会被增加到一个名为 mActivities
的汇合当中所持有。
ActivityClientRecord 是 ActivityThread 的一个动态外部类,用于记录 Activity 相干的信息。其对象的创立过程能够在 LaunchActivityItem 类(Api 28 之后)中找到:
_frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java_:
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions){Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client, mAssistToken);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
再来看一下这个 mActivities
汇合:
frameworks/base/core/java/android/app/ActivityThread.java
:
···
final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
···
mActivities
是一个 map 汇合,为 ActivityThread 对象的一个成员变量。既然是一个汇合,天然也能够在 Activity 销毁办法回调中找到移除汇合内元素的操作:
/** Core implementation of activity destroy call. */
ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
int configChanges, boolean getNonConfigInstance, String reason){ActivityClientRecord r = mActivities.get(token);
···
synchronized (mResourcesManager) {mActivities.remove(token);
}
StrictMode.decrementExpectedActivityCount(activityClass);
return r;
}
图形关系示意如下:
既然 Activity 的对象是间接被 ActivityThread 对象所持有援用,那么该 ActivityThread 对象理当是单例的模式存在,那么该单例 ActivityThread 对象又是如何被创立以及持有的呢?
ActivityThread 对象的创立
一个新的利用过程创立时,会调用 ActivityThread 的动态主办法 main()
,在这里,咱们找到了答案:
_frameworks/base/core/java/android/app/ActivityThread.java_:
···
// 注解 4:动态的 ActivityThread 成员变量,用于实现单例
private static volatile ActivityThread sCurrentActivityThread;
···
// 注解 5: ActivityThread 的主办法入口,由 RuntimeInit 调用
public static void main(String[] args) {
···
Looper.prepareMainLooper();
···
// 注解 6: 新建一个 ActivityThread 对象
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
···
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
···
private void attach(boolean system, long startSeq) {
// 注解 7: ActivityThread 对象由动态成员变量所援用
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManager.getService();
try {mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();
}
···
} ···
}
由下面的代码可知,一个新的利用过程创立时,main()
办法里新建一个 ActivityThread 对象赋予给 ActivityThread 类的一个动态成员变量 sCurrentActivityThread
,从而造成 一个利用过程对应一个 ActivityThread 对象(单例) 的关系。
总结
每一个新启动的 Activity,其对象实例通过 Class 类的 newInstance
办法创立后,被包裹在一个 ActivityClientRecord 对象中而后增加到过程惟一的 ActivityThread 对象的成员变量 mActivitys 里。换言之,Activity 对象的持有和开释都是由 ActivityThread 来治理的。
最初,笔者想额定重申:
- 源码中,Activity 对象会在多个办法都有传递关系,比较复杂,笔者满腹经纶,可能会漏掉一些别的重要的援用关系没有剖析,欢送大家斧正。
最初
其实对于程序员来说,要学习的常识内容、技术有太多太多,要想不被环境淘汰就只有一直晋升本人,素来都是咱们去适应环境,而不是环境来适应咱们!
这里是对于 我本人的 Android 学习材料整顿,蕴含面试文档,视频收集大整顿,有趣味的搭档们能够看看~