AI 助理
备案控制台
开发者社区 微服务 文章 正文

Android应用程序框架之Home程序（Launcher）

2016-11-05 1556
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 上一篇博客我们讲了PackageManagerService的启动过程以及对于应用程序的注册过程，当系统启动完成后，系统需要开启第一个应用程序，这就是Home程序，也就是我们熟知的桌面程序。本篇博客主要介绍Home的启动过程。 通过上一篇博客介绍，我们知道系统在启动的时候会启动SystemServer,并且在SystemServer中会启动一系列的Service，包括Pac

上一篇博客我们讲了PackageManagerService的启动过程以及对于应用程序的注册过程，当系统启动完成后，系统需要开启第一个应用程序，这就是Home程序，也就是我们熟知的桌面程序。本篇博客主要介绍Home的启动过程。
通过上一篇博客介绍，我们知道系统在启动的时候会启动SystemServer,并且在SystemServer中会启动一系列的Service，包括PackageManagerService,ActivityManagerService等等，而ActivityManagerService在启动后就会负责Home的启动。所以一开始先来看看ActivityManagerService的启动。

1.ActivityManagerService

通过前一篇博客的介绍，我们知道SystemServer在启动后会开启一个线程ServerThread来启动各种系统级Service，其中就包括ActivityManagerService,ServerThread的run函数可以参看上一篇博客。接下来看看ActivityManagerService启动后都干些什么。

1 ActivityManagerService.main 

public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    ......
    public static final Context main(int factoryTest) {
        AThread thr = new AThread();
        thr.start();

        synchronized (thr) {
            while (thr.mService == null) {
                try {
                    thr.wait();
                } catch (InterruptedException e) {
                }
            }
        }

        ActivityManagerService m = thr.mService;
        mSelf = m;
        ActivityThread at = ActivityThread.systemMain();
        mSystemThread = at;
        Context context = at.getSystemContext();
        m.mContext = context;
        m.mFactoryTest = factoryTest;
        m.mMainStack = new ActivityStack(m, context, true);

        m.mBatteryStatsService.publish(context);
        m.mUsageStatsService.publish(context);

        synchronized (thr) {
            thr.mReady = true;
            thr.notifyAll();
        }

        m.startRunning(null, null, null, null);
        return context;
    }
    ......
}

这个函数首先通过AThread线程对象来内部创建了一个ActivityManagerService实例，然后将这个实例保存其成员变量mService中，接着又把这个ActivityManagerService实例保存在ActivityManagerService类的静态成员变量mSelf中，最后初始化其它成员变量，就结束了。

2.ActivityManagerService.setProcessSystem 

public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    ......

    public static void setSystemProcess() {
        try {
            ActivityManagerService m = mSelf;

            ServiceManager.addService("activity", m);
            ServiceManager.addService("meminfo", new MemBinder(m));
            if (MONITOR_CPU_USAGE) {
                ServiceManager.addService("cpuinfo", new CpuBinder(m));
            }
            ServiceManager.addService("permission", new PermissionController(m));

            ApplicationInfo info =
                mSelf.mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS);
            mSystemThread.installSystemApplicationInfo(info);

            synchronized (mSelf) {
                ProcessRecord app = mSelf.newProcessRecordLocked(
                    mSystemThread.getApplicationThread(), info,
                    info.processName);
                app.persistent = true;
                app.pid = MY_PID;
                app.maxAdj = SYSTEM_ADJ;
                mSelf.mProcessNames.put(app.processName, app.info.uid, app);
                synchronized (mSelf.mPidsSelfLocked) {
                    mSelf.mPidsSelfLocked.put(app.pid, app);
                }
                mSelf.updateLruProcessLocked(app, true, true);
            }
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException(
                "Unable to find android system package", e);
        }
    }
    ......
}

这个函数主要做了两件事，第一是将ActivityManagerService实例添加到ServiceManager中，这样其他组件就可以通过getSystemService接口来获取到ActivityManagerSerivce了。
第二件事就是通过调用mSystemThread.installSystemApplicationInfo函数来把应用程序框架层下面的android包加载进来。

3.ActivityManagerService.systemReady

接下来ActivityManagerService会调用systemReadey接口。

public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    ......
    public void systemReady(final Runnable goingCallback) {
        ......
        synchronized (this) {
            ......
            mMainStack.resumeTopActivityLocked(null);
        }
    }
    ......
}

这里就是通过mMainStack.resumeTopActivityLocked函数来启动Home应用程序的了，这里的mMainStack是一个ActivityStack类型的实例变量。

2.Home应用程序启动

1.mMainStack.resumeTopActivityLocked

接着上面的指令流继续往下看，前文已经讲到了，mMainStack是一个ActivityStack，即一个activity的栈，每个应用程序都会有一个或多个ActivityStack用来维护activity。而resumeTopActivityLocked就是把栈顶的activity恢复到前台。

public class ActivityStack {
    ......

    final boolean resumeTopActivityLocked(ActivityRecord prev) {
        // Find the first activity that is not finishing.
        ActivityRecord next = topRunningActivityLocked(null);
        ......
        if (next == null) {
            // There are no more activities!  Let's just start up the
            // Launcher...
            if (mMainStack) {
                return mService.startHomeActivityLocked();
            }
        }
        ......
    }
    ......
}

由于当前Home应用程序并没有启动，所以next为null，进而会调用mService.startHomeActivityLocked来启动Home程序。

2.mService.startHomeActivityLocked 

public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    ......
    boolean startHomeActivityLocked() {
        ......
        Intent intent = new Intent(
            mTopAction,
            mTopData != null ? Uri.parse(mTopData) : null);
        intent.setComponent(mTopComponent);
        if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
            intent.addCategory(Intent.CATEGORY_HOME);
        }
        ActivityInfo aInfo =
            intent.resolveActivityInfo(mContext.getPackageManager(),
            STOCK_PM_FLAGS);
        if (aInfo != null) {
            intent.setComponent(new ComponentName(
                aInfo.applicationInfo.packageName, aInfo.name));
            // Don't do this if the home app is currently being
            // instrumented.
            ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                aInfo.applicationInfo.uid);
            if (app == null || app.instrumentationClass == null) {
                intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
                mMainStack.startActivityLocked(null, intent, null, null, 0, aInfo,
                    null, null, 0, 0, 0, false, false);
            }
        }
        return true;
    }
    ......
}

在这个函数中，可以看到AMS会创建一个intent实例，并且设置其category为HOME。而category为Home当然就是Home程序的启动Activity。接下来通过resolveActivityInfo向PackageManagerService查询对应的Activity，当然就是Home程序的Activity了。接下来通过mMainStack.startActivityLocked就启动了Home程序。

3.Launcher.onCreate 

public final class Launcher extends Activity
        implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
    ......
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ......
        if (!mRestoring) {
            mModel.startLoader(this, true);
        }
        ......
    }
    ......
}

public class LauncherModel extends BroadcastReceiver {
    ......

    public void startLoader(Context context, boolean isLaunching) {
        ......

                synchronized (mLock) {
                     ......

                     // Don't bother to start the thread if we know it's not going to do anything
                     if (mCallbacks != null && mCallbacks.get() != null) {
                         // If there is already one running, tell it to stop.
                         LoaderTask oldTask = mLoaderTask;
                         if (oldTask != null) {
                             if (oldTask.isLaunching()) {
                                 // don't downgrade isLaunching if we're already running
                                 isLaunching = true;
                             }
                             oldTask.stopLocked();
                 }
                 mLoaderTask = new LoaderTask(context, isLaunching);
                 sWorker.post(mLoaderTask);
                }
           }
    }

    ......
}

通过上面两段代码可以发现，在Launcher的onCreate初始化函数中，通过mModel来加载Loader，这里的mModel是一个LauncherModel类型的成员变量。 这里不是直接加载应用程序，而是把加载应用程序的操作作为一个消息来处理。这里的sWorker是一个Handler，通过它的post方式把一个消息放在消息队列中去，然后系统就会调用传进去的参数mLoaderTask的run函数来处理这个消息，这个mLoaderTask是LoaderTask类型的实例，于是，下面就会执行LoaderTask类的run函数了。

4.LoaderTask.loadAllAppsByBatch

在LoaderTask的run函数会调用loadAndBindAllApps,而在这个函数中又会调用loadAllAppsByBatch,所以真正启动各个app的工作是在这个函数中执行的。

public class LauncherModel extends BroadcastReceiver {
    ......
    private class LoaderTask implements Runnable {
        ......
        private void loadAllAppsByBatch() { 
            ......
            final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
            mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);

            final PackageManager packageManager = mContext.getPackageManager();
            List<ResolveInfo> apps = null;

            int N = Integer.MAX_VALUE;

            int startIndex;
            int i=0;
            int batchSize = -1;
            while (i < N && !mStopped) {
                if (i == 0) {
                    mAllAppsList.clear();
                    ......
                    apps = packageManager.queryIntentActivities(mainIntent, 0);
                    ......
                    N = apps.size();            
                    ......
                    if (mBatchSize == 0) {
                        batchSize = N;
                    } else {
                        batchSize = mBatchSize;
                    }
                    ......
                    Collections.sort(apps,
                        new ResolveInfo.DisplayNameComparator(packageManager));
                }
                startIndex = i;
                for (int j=0; i<N && j<batchSize; j++) {
                    // This builds the icon bitmaps.
                    mAllAppsList.add(new ApplicationInfo(apps.get(i), mIconCache));
                    i++;
                }

                final boolean first = i <= batchSize;
                final Callbacks callbacks = tryGetCallbacks(oldCallbacks);
                final ArrayList<ApplicationInfo> added = mAllAppsList.added;
                mAllAppsList.added = new ArrayList<ApplicationInfo>();

                mHandler.post(new Runnable() {
                    public void run() {
                        final long t = SystemClock.uptimeMillis();
                        if (callbacks != null) {
                            if (first) {
                                callbacks.bindAllApplications(added);
                            } else {
                                callbacks.bindAppsAdded(added);
                            }
                            ......
                        } else {
                            ......
                        }
                    }
                });
                ......
            }
            ......
        }
        ......
    }
    ......
}

函数首先构造一个CATEGORY_LAUNCHER类型的Intent,接着从mContext变量中获得PackageManagerService的接口。下一步就是通过这个PackageManagerService.queryIntentActivities接口来取回所有Action类型为Intent.ACTION_MAIN，并且Category类型为Intent.CATEGORY_LAUNCHER的Activity了。从queryIntentActivities函数调用处返回所要求的Activity后，便调用函数tryGetCallbacks(oldCallbacks)得到一个返CallBack接口，这个接口是由Launcher类实现的，接着调用这个接口的.bindAllApplications函数来进一步操作。注意，这里又是通过消息来处理加载应用程序的操作的。

5.Launcher.bindAllApplications 

public final class Launcher extends Activity
        implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
    ......
    private AllAppsView mAllAppsGrid;
    ......
    public void bindAllApplications(ArrayList<ApplicationInfo> apps) {
        mAllAppsGrid.setApps(apps);
    }
    ......
}

函数很简单，就是调用了mAllAppsGrid.setApps(apps)。这里的mAllAppsGrid是一个AllAppsView类型的变量，它的实际类型一般就是AllApps2D了。所以这个函数的作用很清晰了，就是在Home界面绘制各个应用的图标。具体的绘制逻辑这里就不多讲了。
到这里Home应用程序的启动过程就介绍完了。虽然函数的调用过程比较复杂，但其实总的逻辑还是比较简单的:

  1. 创建ActivityManagerService；
  2. ActivityManagerService通过mMainStack来启动Home程序
  3. mMainStack向PackageManagerService查询Home程序的Activity，然后启动该Activity，并放入该mMainStack中
  4. Home程序启动后通过PackageManagerService查询所有应用程序的启动Activity
  5. Home程序在初始化的时候绘制Home界面
  6. 当点击某个应用程序图标的时候，启动对应应用程序的启动Activity
文章标签：
Android开发
消息中间件
关键词：
Android应用
Android框架
Android应用程序
Android程序
Android应用launcher
李牙刷儿
目录
相关文章
CamilleKing
|
2天前
|
算法 Java 数据库
Android 应用的主线程在什么情况下会被阻塞？
【10月更文挑战第20天】为了避免主线程阻塞，我们需要合理地设计和优化应用的代码。将耗时操作移到后台线程执行，使用异步任务、线程池等技术来提高应用的并发处理能力。同时，要注意避免出现死循环、不合理的锁使用等问题。通过这些措施，可以确保主线程能够高效地运行，提供流畅的用户体验。
CamilleKing
8 2
mrq4nk6ni2neg
|
5天前
|
Java API Android开发
安卓应用程序开发的新手指南：从零开始构建你的第一个应用
【10月更文挑战第20天】在这个数字技术不断进步的时代，掌握移动应用开发技能无疑打开了一扇通往创新世界的大门。对于初学者来说，了解并学习如何从无到有构建一个安卓应用是至关重要的第一步。本文将为你提供一份详尽的入门指南，帮助你理解安卓开发的基础知识，并通过实际示例引导你完成第一个简单的应用项目。无论你是编程新手还是希望扩展你的技能集，这份指南都将是你宝贵的资源。
mrq4nk6ni2neg
25 5
游客moiomvrp3vyac2
|
5天前
|
移动开发 Dart 搜索推荐
打造个性化安卓应用：从零开始的Flutter之旅
【10月更文挑战第20天】本文将引导你开启Flutter开发之旅，通过简单易懂的语言和步骤，让你了解如何从零开始构建一个安卓应用。我们将一起探索Flutter的魅力，实现快速开发，并见证代码示例如何生动地转化为用户界面。无论你是编程新手还是希望扩展技能的开发者，这篇文章都将为你提供价值。
游客moiomvrp3vyac2
20 5
mzlogin
|
5天前
|
Java 程序员 API
Android｜集成 slf4j + logback 作为日志框架
做个简单改造，统一 Android APP 和 Java 后端项目打印日志的体验。
mzlogin
23 1
东方睿赢
|
15天前
|
调度 Android开发 开发者
构建高效Android应用：探究Kotlin多线程优化策略
【10月更文挑战第11天】本文探讨了如何在Kotlin中实现高效的多线程方案，特别是在Android应用开发中。通过介绍Kotlin协程的基础知识、异步数据加载的实际案例，以及合理使用不同调度器的方法，帮助开发者提升应用性能和用户体验。
东方睿赢
36 4
东方睿赢
|
15天前
|
编解码 Android开发 UED
构建高效Android应用：从内存优化到用户体验
【10月更文挑战第11天】本文探讨了如何通过内存优化和用户体验改进来构建高效的Android应用。介绍了使用弱引用来减少内存占用、懒加载资源以降低启动时内存消耗、利用Kotlin协程进行异步处理以保持UI流畅，以及采用响应式设计适配不同屏幕尺寸等具体技术手段。
东方睿赢
36 2
Codelinghu
|
19天前
|
Android开发
Android开发显示头部Bar的需求解决方案--Android应用实战
Android开发显示头部Bar的需求解决方案--Android应用实战
Codelinghu
16 0
游客moiomvrp3vyac2
|
22天前
|
缓存 搜索推荐 Android开发
安卓开发中的自定义控件实践
【10月更文挑战第4天】在安卓开发的海洋中，自定义控件是那片璀璨的星辰。它不仅让应用界面设计变得丰富多彩，还提升了用户体验。本文将带你探索自定义控件的核心概念、实现过程以及优化技巧，让你的应用在众多竞争者中脱颖而出。
游客moiomvrp3vyac2
51 2
shuj
|
22天前
|
Java Android开发 Swift
安卓与iOS开发对比：平台选择对项目成功的影响
【10月更文挑战第4天】在移动应用开发的世界中，选择合适的平台是至关重要的。本文将深入探讨安卓和iOS两大主流平台的开发环境、用户基础、市场份额和开发成本等方面的差异，并分析这些差异如何影响项目的最终成果。通过比较这两个平台的优势与挑战，开发者可以更好地决定哪个平台更适合他们的项目需求。
shuj
84 1
aqi00
|
23天前
|
Web App开发 安全 程序员
FFmpeg开发笔记（五十五）寒冬里的安卓程序员可进阶修炼的几种姿势
多年的互联网寒冬在今年尤为凛冽，坚守安卓开发愈发不易。面对是否转行或学习新技术的迷茫，安卓程序员可从三个方向进阶：1）钻研谷歌新技术，如Kotlin、Flutter、Jetpack等；2）拓展新功能应用，掌握Socket、OpenGL、WebRTC等专业领域技能；3）结合其他行业，如汽车、游戏、安全等，拓宽职业道路。这三个方向各有学习难度和保饭碗指数，助你在安卓开发领域持续成长。
aqi00
53 1
FFmpeg开发笔记（五十五）寒冬里的安卓程序员可进阶修炼的几种姿势