Android FrameWork 之ActivityThread 源码

Android源码解析系列1——Activity启动和界面加载,别再说你不会 // needs to be visible but isn’t in the foreground. We accomplish this by going // through the normal startup (because activities expect to go through onResume() // the first time they run, before their window is displayed), and then pausing it. // However 阅读详情

由之前的源码 我们知道ActivityThread 的创建是在SystemServe中开始的 

SystemServer.java run 方法
private void run() {
        try {
        Looper.prepareMainLooper();
        Looper.getMainLooper().setSlowLogThresholdMs(
       SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
  
        //创建SystemContext 由ActivityThread 创建 
        createSystemContext();
        // Loop forever.
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

     private void createSystemContext() {
        ActivityThread activityThread = ActivityThread.systemMain();
        mSystemContext = activityThread.getSystemContext();
        final Context systemUiContext = activityThread.getSystemUiContext();
        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
    }

我们先看一下 ActivityThread.systemMain 

public static ActivityThread systemMain() {
        ActivityThread thread = new ActivityThread();//创建了ActivityThread 对象
        thread.attach(true, 0);
        return thread;
    }

 private void attach(boolean system, long startSeq) {
        sCurrentActivityThread = this;
            try {
                mInstrumentation = new Instrumentation();
                mInstrumentation.basicInit(this);
                ContextImpl context = ContextImpl.createAppContext(
                        this, getSystemContext().mPackageInfo);
                mInitialApplication = context.mPackageInfo.makeApplication(true, null);
                mInitialApplication.onCreate();
            } catch (Exception e) {
                throw new RuntimeException(
                        "Unable to instantiate Application():" + e.toString(), e);
            }
        }

    }

     创建ActivityThread的同时又调用了ContextImpl 的createAppContext 方法 跟下去到了createSystemContext 然后我们这里就创建了ContextImpl对象 

 static ContextImpl createSystemContext(ActivityThread mainThread) {
        LoadedApk packageInfo = new LoadedApk(mainThread);
        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, 
        null, null, 0,
                null, null);
        context.setResources(packageInfo.getResources());
       context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
                context.mResourcesManager.getDisplayMetrics());
        return context;
    }

然后们看看 这个makeApplication  到底干了什么 

public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
            //applcation 不为空 直接返回
        if (mApplication != null) {
            return mApplication;
        }
        Application app = null;
        String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";//Application 的class 名字 
        }
        try {
            java.lang.ClassLoader cl = getClassLoader(); //拿到classloader 
            ...........
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);

            //mInstrumentation  new 出 一个application 
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
        } 
        mActivityThread.mAllApplications.add(app);
        mApplication = app;
        ................
        return app;
    }

newApplication -------->

 
public Application newApplication(ClassLoader cl, String className, Context context){
        Application app = getFactory(context.getPackageName())
                .instantiateApplication(cl, className);
        app.attach(contxt);//将context 传给Application 
        return app;
    }

instantiateApplication-------->
 反射创建Applicaiton 
 public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,
            @NonNull String className){
        return (Application) cl.loadClass(className).newInstance();
    }

从上面这几块我们可以看到 Application 就创建了 但是这个Application 并不是我们开发出来的应用的Application 我会在之后再写一篇关于应用启动的过程

扯远了 我们回到ActivityThread 看看这货 里面还有啥别的东西 我们从main 方法看看 

public static void main(String[] args) {
        ...........
       //?主线成 Looper 在这里创建了。。 
        Looper.prepareMainLooper();
        long startSeq = 0;
        if (args != null) {
            for (int i = args.length - 1; i >= 0; --i) {
                if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
                    startSeq = Long.parseLong(
                            args[i].substring(PROC_START_SEQ_IDENT.length()));
                }
            }
        }
        ...........
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);
        if (sMainThreadHandler == null) {
        //? handler  熟悉吗。。 原来这里也有个Handler 
            sMainThreadHandler = thread.getHandler();
        }
        Looper.loop();
}

发现这里也有个handler 我们看看 它这个handler 是啥 

class H extends Handler {
  此处省略一万行原代码
  public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
            switch (msg.what) {
                case BIND_APPLICATION:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
                    AppBindData data = (AppBindData)msg.obj;
                    handleBindApplication(data);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case EXIT_APPLICATION:
                    if (mInitialApplication != null) {
                        mInitialApplication.onTerminate();
                    }
                    Looper.myLooper().quit();
                    break;
                case RECEIVER:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
                    handleReceiver((ReceiverData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case CREATE_SERVICE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.valueOf(msg.obj)));
                    handleCreateService((CreateServiceData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case BIND_SERVICE:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
                    handleBindService((BindServiceData)msg.obj);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                ............
                case RELAUNCH_ACTIVITY:
                    handleRelaunchActivityLocally((IBinder) msg.obj);
                    break;

}

看这个case  大概也能猜出来一些吧。。 什么 我们调用的 bindservice  createservice   原来都是在这里处理的。 也是消息机制 接收的。有兴趣的大家可以再 详细看看 源码 很多 平时用的东西这里都能看到

然后我们看看 这个main 方法里面的attach 方法  上面看了一下 attach  是 system server 调用的 ,我们看到它的参数前一个是boolean 值 如果是正常App 启动 这个boolean 值是false  所以我们看看源码 

 private void attach(boolean system, long startSeq) {
        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();
            }
           
        } else {
            
            android.ddm.DdmHandleAppName.setAppName("system_process",
                    UserHandle.myUserId());
            try {
                mInstrumentation = new Instrumentation();
                mInstrumentation.basicInit(this);
                ContextImpl context = ContextImpl.createAppContext(
                        this, getSystemContext().mPackageInfo);
                mInitialApplication = context.mPackageInfo.makeApplication(true,    
                mInitialApplication.onCreate();
       
                }
    }

上面的代码 我们看到 如果不是system 走if 逻辑 调用了IActivityManager 的 attachApplication 方法 IActivityManager 就是ActivityManagerService 

ActiviyManagerService.java  attachApplication()--------> 

  public final void attachApplication(IApplicationThread thread, long startSeq) {
        synchronized (this) {
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
            Binder.restoreCallingIdentity(origId);
        }
    }
attachApplicationLocked ----->

 private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
...省略一万行代码 
thread.bindApplication(processName, appInfo, providers,
                        instr2.mClass,
                        profilerInfo, instr2.mArguments,
                        instr2.mWatcher,
                        instr2.mUiAutomationConnection, testMode,
                        mBinderTransactionTrackingEnabled, enableTrackAllocation,
                        isRestrictedBackupMode || !normalMode, app.isPersistent(),
                        new Configuration(app.getWindowProcessController().getConfiguration()),
                        app.compat, getCommonServicesLocked(app.isolated),
                        mCoreSettingsObserver.getCoreSettingsLocked(),
                        buildSerial, autofillOptions, contentCaptureOptions);
}

ActivityThread.java   thread.bindApplication--->
 
public final void bindApplication(String processName, ApplicationInfo appInfo,
                List<ProviderInfo> providers, ComponentName instrumentationName,
                ProfilerInfo profilerInfo, Bundle instrumentationArgs,
                IInstrumentationWatcher instrumentationWatcher,
                IUiAutomationConnection instrumentationUiConnection, int debugMode,
                boolean enableBinderTracking, boolean trackAllocation,
                boolean isRestrictedBackupMode, boolean persistent, Configuration config,
                CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
                String buildSerial, AutofillOptions autofillOptions,
                ContentCaptureOptions contentCaptureOptions) {
//发送消息给handler 
sendMessage(H.BIND_APPLICATION, data);
}


handler---->


 public void handleMessage(Message msg) {

            switch (msg.what) {
                case BIND_APPLICATION:
                    handleBindApplication(data);
                    break;

}

handleBindApplication ---->

private void handleBindApplication(AppBindData data) {

 Application app;
        try {
           data.info 其实就是loadApk 对象 
            app = data.info.makeApplication(data.restrictedBackupMode, null);
}

LoadApk.java  makeApplication----->

public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
       //如果存在直接返回
        if (mApplication != null) {
            return mApplication;
        }
        Application app = null;

        try {
            java.lang.ClassLoader cl = getClassLoader();

            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
         
        mActivityThread.mAllApplications.add(app);
        mApplication = app;
        if (instrumentation != null) {
            try {
                // 这里是调用了Application的Oncreate 方法 
                instrumentation.callApplicationOnCreate(app);
            } 
        }

上面这一圈儿 就是想 给大家看下 App 启动以后 Application 为什么是首先创建的。。  

最后回顾一下从Init 到ActivityThread的整体流程 

系统开机 进行一些系统启动加载 硬件初始化等 -----> 加载Init 进程  -----> 解析init.rc  ------> 创建了zygote  ,servicemanager 等系统进程 -----> zygote   fork 出systemserver 进程 ------> jni 调用Systemserver.java 的run 方法----->  开启其他服务 ams wms 等等 以及 创建了ActivityThread  还有就是开启了Launcher Activity 我们看到了桌面 

 

android源码宇宙-activity启动源码 Activity栈中的一个节点,用于展示一个Activity它集成了WindowToken实现了WindowManagerService中的一个接口既然如此顺便看看WindowToken吧用来替代ActivityStackSupervisor这东西是ActivityThread中的一个变量它可以作为一个测试框架的根基,因为它是先于我们的Application和Activity启动的,所以它可以监听到我们创建Activity和Application操作。android是支持自定义Instrumentation 阅读详情

相关推荐

Android Framework源码解析篇~_android framework 源码开发手册

下面都是 通过binder发送到ApplicationThread由它调用ActivityThread父类的 scheduleTransaction最后在TransactionExecutor(ClientTransactionHandler)的 executeCallbacks,executeLifecycleState 中调用对应的 execute方法,分配到对应的 ActivityThread 的各个生命周期调用里。

2401_87022349的博客 1365

Framework - SystemServer

一共启动了12个服务:Installer、DeviceIdentifiersPolicyService、ActivityManagerService、PowerManagerService、RecoverySystemService、LightsService、StartSidekickService、DisplayManagerService、PackageManagerService、UserManagerService、OverlayManagerService、SensorService。

HugMua的博客 790

Framework简介

这里写自定义目录标题简单介绍framework在Android系统的位置Android架构图Android系统源码中的framework重要类及其介绍服务端客户端Linux驱动从apk程序的运行过程,去看看上面各个组件在啥时候干啥活的源码地址FrameWork的开发1 源码的目录结构。2 Framework 的学习方法汇总3 Framework启动分析应用程序启动分析APK中的线程自定义Thre...

mybook1122的专栏 6624

Android 系统调试技巧

1.实时跟踪Kernel Log,主要命令dmesg,详细用法可以使用-h选项查看,如实时查看kernel Log信息 adb shell dmesg -T -w 会不断将Kernel Buffer Log吐出 2.logcat 工具,除了常用的过滤,还可以根据pid过滤 如adb logcat --pid xx 只看某个进程的log 3.某个进程卡死,但是又没有生成ANR或者其它DB...

wangchezheng的专栏 578

使用SourceInsight查看Framework的源码(如ActivityThread、ContextImpl类的源码)

不诗意的女程序猿不是好厨师~ 【转载请注明出处:From李诗雨—】 事情原由,ps:可直接忽略跳过~ 由于项目中我对Service的使用不当造成了一个bug,经过反思,我觉得还是因为自己基础不扎实造成的。于是又看了一遍《第一行代码》和《Android开发艺术探索》中关于Service的部分,好吧,确实是“书读百遍,其意自见”,这次的阅读又令我有了不一样的收获和感悟。突然觉得无论是学习还是其他,...

cjm2484836553的博客 1058

Android 12.0 系统中framework中关于Activitity的生命周期的源码讲解

在12.0的系统rom定制化开发中,在framework中对activitity的生命周期的掌握和了解也是非常重要的,这样有利于在启动某个app的activity的页面的时候,可以 监听到是在启动 resume stop的过程,也好进行相关的功能开发,接下来就分析下Activity的相关生命周期的代码

安卓兼职framework和app工程师的博客 879

Jni WindowManager窗口服务

jobject getApplication(JNIEnv *env) { //获取app信息 jobject app = NULL; jclass jc_actThread = env->FindClass("android/app/ActivityThread"); if (jc_actThread != NULL) { jmethodID jm_curActThread = env->GetStaticM.

qq_44782901的博客 422

Android 11.0 framework关于systemUI定制之导航栏透明背景的功能实现

在11.0的系统rom产品定制化开发中,在对于系统原生SystemUI的导航栏背景在沉浸式导航栏的 情况下默认是会随着背景颜色的变化而改变的,在一些特定背景下导航栏的背景也是会改变的,所以由于产品开发需要 要求需要设置导航栏背景为透明的,所以就需要在Activity创建的时候设置导航栏的背景色来完成功能的开发

安卓兼职framework和app工程师的博客 1528

Android 架构篇----------Framework初识

组件的管理,android的四大组件 Activity Broadcast Content Provider  Service (2)WindowManagerService(Wms)管理程序的窗口的,动画,等 简单来说跟View有关的都离不开它。 (3)KeyQ类是Wms的一个内部类一但创建就会启动一个新线程,这个线程会不断的接受有关UI的一些消息,将其放到QueueEvent的消息队列中。 (4)InputDispatcherThread类该类也是一但创建线程就会不断的从上main的

m0_68838647的博客 299

Android 10.0 framework关于systemUI状态栏透明背景的功能实现

在10.0的系统产品定制化开发中,在对于系统原生SystemUI的状态栏背景在沉浸式状态栏的 情况下默认是会随着背景颜色的变化而改变的,在一些特定背景下状态栏的背景也是会改变的,所以由于产品开发需要 要求需要设置状态栏背景为透明的,所以就需要在Activity创建的时候设置状态栏的背景色来完成功能的开发

安卓兼职framework和app工程师的博客 1005

Android 11.0 framework关于systemUI状态栏透明背景的功能实现

在11.0的系统rom产品定制化开发中,在对于系统原生SystemUI的状态栏背景在沉浸式状态栏的 情况下默认是会随着背景颜色的变化而改变的,在一些特定背景下状态栏的背景也是会改变的,所以由于产品开发需要 要求需要设置状态栏背景为透明的,所以就需要在Activity创建的时候设置状态栏的背景色来完成功能的开发

安卓兼职framework和app工程师的博客 1444

2024上半年百度Android岗(初级到高级)面试真题全收录+解析,备战金九银十(2)

【Android 详细知识点思维脑图(技能树)】我个人是做Android开发,已经有十来年了,目前在某创业公司任职CTO兼系统架构师。虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司19年的面试题。

2301_82242351的博客 1130

Android 全局架构与源码阅读方法

本文是Android系统架构与源码阅读方法的开篇章,重点帮助开发者建立全局视角。文章首先指出仅学习API层面的开发会导致对Android运行机制理解不足,无法解决Activity生命周期、Binder通信等核心问题。

9年Android老兵,专注车载系统与移动架构。深耕Java/Kotlin,玩转Lua/Python。擅长百度/高德地图深度定制,分享拒绝浅尝辄止的硬核干货。 43

Eclipse中通过反编译看不到ActivityThread的源码,Why?

Eclipse中通过反编译看不到ActivityThread的源码,Why?

Younge的专栏 2086

在Mac下配置用VSCode编写C/C++程序的环境

前言    最近需要编写一些C/C++程序,由于体量都不是很大所以想要追求一个轻量化的编辑和编译环境,于是想起了在Dock栏吃灰的VSCode。通过查找资料,包括VSCode的官方文档,最终配置实现了Mac下基于VSCode的C/C++编辑环境搭建。 正文    在配置环境之前先检查一下机器上都安装了什么C++编译器,通过以下两条命令可以查看是否安装了g++/clang编译器,本人两种编...

Kalikali的专栏 5万+

直流电机双闭环调速系统MATLAB仿真

Chopper-Fed DC Motor Drive This example shows a Chopper-Fed DC Motor Drive. Description The DC motor is fed by the DC source through a chopper which consists of GTO thyristor and free-wheeling diode ...

飞行动力的博客 2万+

Android framework 源码分析一Activity启动流程(android 8.0)

Android framework 源码分析之Activity启动流程android 8.0概述Activity的启动流程 概述 Android系统对四大组件的工作过程进行了很大程度的封装,方便开发者使用,Activity作为Android中四大组件之一,直接跟用户进行交互,对于用户来说activity就是应用的一切,系统对其工作流程当然也做了很多封装,本篇文章将介绍Activity的启动流程,在...

马彦虎的博客 7089

两层板如何做阻抗控制呢

两层板如何做阻抗控制呢? 这个问题可能很多人都会碰到,有的人在此等需要做阻抗控制的情况都选择做多层板。诚然,多层板在阻抗控制,EMC等等方面都有着天然的优势。然而,在价格上和周期上,两层板就有着绝对优势了。 对于成本非常敏感而又不是太复杂的产品,尽管对于我们硬件工程师而言,有一堆的理由要求使用多层板。然而在面对毛都不懂的老板“别人能做,你为什么不能做?”这个问题时只得低下我们高傲的头颅。 好...

weixin_42005993的博客 2万+

Android秋招笔试复盘:从热词看考点,源码级工程化指南

Android开发技术栈日益庞大,从构建工具链到系统底层机制,持续演进与更新。理解核心原理不仅是日常开发的基础,更是应对技术面试与笔试的关键。工程化实践中,AGP等构建工具的行为变化、R8的混淆与优化规则,都直接影响应用的最终产物与运行表现。同时,掌握Handler消息机制、Binder跨进程通信等系统级知识,能够帮助开发者更好地设计健壮的应用架构,并处理复杂场景下的问题。无论是性能优化、UI架构设计,还是模块化开发,这些底层认知都构成了Android技术能力的基石。本文基于2023年秋招Android研发

weixin_30983965的博客 289

VMware VSAN 高级参数介绍(测试用)

VSAN 的策略驱动让我们看到了VSAN无穷的潜力,其设计思路相当新颖,在一个基础资源池上使用策略就能实现不同对象的区分服务,而目前没有其他厂家能到VMware这样的高度。 VSAN 呈现给用户配置很简单,但实际上设计及后台比较复杂。笔者无意间发现了VSAN的隐藏高级参数设置,有很多好玩的选项想分享出来。这些参数全部是针对每主机进行设置的。VSAN 中有很多默认设置,这些设置应该都是研发人员多次测试得出的最优值,修改可能导致环境异常,并不建议修改! 目录 参数1:全闪配置下 SSD 写缓存最大.

山水牧羊 2032

【Unity+HoloLens2】从0开始在HoloLens2部署MR工程

HoloLens2部署的权威教程在微软的官方文档中,但有些问题其实官方文档并没有列出,所以在实际开发过程中如果遇到bug,就需要自身或者前人的经验去解决。比如:对于Hololens2来说,在VS中需选择ARM64而不是x86。部署需要有良好的网速;工程打包出来的文件路径和工程路径有关联,如果这两个路径不匹配,部署就会失败。部署后打不开可能是因为Unity中未添加需要部署的场景,在Build Settings中点击Add open Scenes。...

fmxs 4571
上一篇: Android FrameWork 之Launcher启动源码
下一篇: Android Framework 之 zygote 副篇
Yeyu-Lab
博客等级 码龄11年 13粉丝 107原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值