Context与ActivityManagerService

原创 2017年01月03日 00:28:48


        Context ,字面意思上理解是上下文。若从其源码的角度说,它是一个抽象类,并定义了一些基本的方法;Activity、Application、Service统统都是一个 Context。下图描述了这些类继承的关系。


1、Context系列类

(1)ContextImpl是Context抽象类的实现;

(2)ContextWrapper是包装类,最终是调用ContextImpl中的方法,是为了降低Activity、Service对ContextImpl的耦合性;

  Context mBase;

    public ContextWrapper(Context base) {
        mBase = base;
    }
    
    protected void attachBaseContext(Context base) {
        if (mBase != null) {
            throw new IllegalStateException("Base context already set");
        }
        mBase = base;
    }

(3)Service与Application继承了ContextWrapper类;

(4)Activity则继承了ContextThemeWrapper。


2、ActivityManagerService分析

          AMS是一个及其重要的系统服务,是四大组件的管理核心,负责其启动、切换、调度及应用进程的管理和调度等工作。.其采用了Proxy-stub设计模式,使用binder进行进程间的通信。UML类图如下:


        ActivityManagerProxy就是proxy,ActivityManagerNative(抽象类)就是stub,ActivityManagerService则是真正服务端接口的实现。IServiceManager就是业务接口。Binder详细介绍可以参考:binder解析

       

【AMS的启动】

             system_server进程以startBootstrapServices()方法来启动AMS服务。在startBootstrapServices()中主要完成了以下工作:

(1)创建AMS实例对象,创建Andoid Runtime,ActivityThread和Context对象;
(2)setSystemProcess:注册AMS、meminfo、cpuinfo等服务到ServiceManager;再创建ProcessRecord对象;
(3)installSystemProviderss,加载SettingsProvider;
(4)启动SystemUIService,再调用一系列服务的systemReady()方法;

 private void startBootstrapServices() {
        Installer installer = mSystemServiceManager.startService(Installer.class);

        // Activity manager runs the show.
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();//关键
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
   
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

        mActivityManagerService.initPowerManagement();

        mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

        // We need the default display before we can initialize the package manager.
        mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);

        // Only run "core" apps if we're encrypting the device.
        String cryptState = SystemProperties.get("vold.decrypt");
        if (ENCRYPTING_STATE.equals(cryptState)) {
            Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
            mOnlyCore = true;
        } else if (ENCRYPTED_STATE.equals(cryptState)) {
            Slog.w(TAG, "Device encrypted - only parsing core apps");
            mOnlyCore = true;
        }

        // Start the package manager.
        Slog.i(TAG, "Package Manager");
        mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
        mFirstBoot = mPackageManagerService.isFirstBoot();
        mPackageManager = mSystemContext.getPackageManager();

        Slog.i(TAG, "User Service");
        ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());

        // Initialize attribute cache used to cache resources from packages.
        AttributeCache.init(mSystemContext);

        // Set up the Application instance for the system process and get started.
        mActivityManagerService.setSystemProcess();
    }

        注意到上面的代码并没有直接启动AMS,而是启动AMS的内部类Lifecycle。 这是迫不得已的做法,由于AMS并没有继承SystemService,而是继承了ActivityManagerNative,因此不能直接通过SystemServiceManager的startService直接启动它。
         可以这样理解:内部类Lifecycle对于AMS而言,就像一个适配器一样,让AMS能够像SystemService一样被SystemServiceManager通过反射的方式启动。

2.1、 SystemServiceManager#startService

public SystemService startService(String className) {
     final Class<SystemService> serviceClass;
     try {
          serviceClass = (Class<SystemService>)Class.forName(className);
     } catch (ClassNotFoundException ex) {
...
}
     return startService(serviceClass); 
}
public <T extends SystemService> T startService(Class<T> serviceClass) {
     final String name = serviceClass.getName();

     if (!SystemService.class.isAssignableFrom(serviceClass)) {
           throw new RuntimeException("");
     }
     final T service;
     try {
          Constructor<T> constructor = serviceClass.getConstructor(Context.class);
          // 创建ActivityManagerService.Lifecycle对象  
          service = constructor.newInstance(mContext);
     } catch (Exception ex) {
     throw new RuntimeException();
...
     }
     //注册Lifecycle服务,并添加到成员变量mServices
     mServices.add(service);

     try {
         //启动ActivityManagerService.Lifecycle的onStart() 
         service.onStart();
     } catch (RuntimeException ex) {
         throw new RuntimeException("",ex);
     }
     return service;
}

2.1.1 ActivityManagerService#Lifecycle

public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;

    public Lifecycle(Context context) {
        //Lifecycle由SystemServiceManager启动,传入的context就是SystemServer创建出的SystemContext
        super(context);

        //1、调用AMS的构造函数
        mService = new ActivityManagerService(context);
     }

    @Override
    public void onStart() {
        //2、调用AMS的start函数
        mService.start();
    }

    public ActivityManagerService getService() {
        return mService;
    }
}
2.1.2 ActivityManagerService构造函数

public ActivityManagerService(Context systemContext) {
    //AMS的运行上下文与SystemServer一致
    mContext = systemContext;
    ............
    //取出的是ActivityThread的静态变量sCurrentActivityThread
    //这意味着mSystemThread与SystemServer中的ActivityThread一致
    mSystemThread = ActivityThread.currentActivityThread();
    ............
    mHandlerThread = new ServiceThread(TAG,
            android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    //处理AMS中消息的handler
    mHandler = new MainHandler(mHandlerThread.getLooper());

    //UiHandler对应于Android中的UiThread
    mUiHandler = new UiHandler();

    if (sKillHandler == null) {
        sKillThread = new ServiceThread(TAG + ":kill",
                android.os.Process.THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
        sKillThread.start();
        //用于接收消息,杀死进程
        sKillHandler = new KillHandler(sKillThread.getLooper());
    }

    //创建两个BroadcastQueue,前台的超时时间为10s,后台的超时时间为60s
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "foreground", BROADCAST_FG_TIMEOUT, false);
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "background", BROADCAST_BG_TIMEOUT, true);
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;

    //创建变量,用于存储信息
    mServices = new ActiveServices(this);
    mProviderMap = new ProviderMap(this);
    mAppErrors = new AppErrors(mContext, this);

    //这一部分,分析BatteryStatsService时提过,进行BSS的初始化
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();
    mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.scheduleWriteToDisk();
    mOnBattery = DEBUG_POWER ? true
            : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
    mBatteryStatsService.getActiveStatistics().setCallback(this);

    //创建ProcessStatsService,感觉用于记录进程运行时的统计信息,例如内存使用情况,写入/proc/stat文件
    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

    //启动Android的权限检查服务,并注册对应的回调接口
    mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
    mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
            new IAppOpsCallback.Stub() {
                @Override public void opChanged(int op, int uid, String packageName) {
                    if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
                        if (mAppOpsService.checkOperation(op, uid, packageName)
                                != AppOpsManager.MODE_ALLOWED) {
                            runInBackgroundDisabled(uid);
                        }
                    }
                }
            });

    //用于定义ContentProvider访问指定Uri对应数据的权限,aosp中似乎没有这文件
    mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));

    //创建多用户管理器
    mUserController = new UserController(this);

    //获取OpenGL版本
    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
            ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
    ............
    //资源配置信息置为默认值
    mConfiguration.setToDefaults();
    mConfiguration.setLocales(LocaleList.getDefault());
    mConfigurationSeq = mConfiguration.seq = 1;

    //感觉用于记录进程的CPU使用情况
    mProcessCpuTracker.init();

    //解析/data/system/packages-compat.xml文件,该文件用于存储那些需要考虑屏幕尺寸的APK的一些信息
    //当APK所运行的设备不满足要求时,AMS会根据xml设置的参数以采用屏幕兼容的方式运行该APK
    mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);

    //用于根据规则过滤一些Intent
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);

    //以下的类,似乎用于管理和监控AMS维护的Activity Task信息
    //ActivityStackSupervisor是AMS中用来管理Activity启动和调度的核心类
    mStackSupervisor = new ActivityStackSupervisor(this);
    mActivityStarter = new ActivityStarter(this, mStackSupervisor);
    mRecentTasks = new RecentTasks(this, mStackSupervisor);

    //创建线程用于统计进程的CPU使用情况
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            while (true) {
                try {
                    try {
                        //计算更新信息的等待间隔
                        //同时利用wait等待计算出的间隔时间
                        ......
                    } catch(InterruptedException e) {
                    }
                    //更新CPU运行统计信息
                    updateCpuStatsNow();
                } catch (Exception e) {
                    ..........
                }
            }
        }
    };

    //加入Watchdog的监控
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

2.1.2 ActivityManagerService#start

private void start() {
    //完成统计前的复位工作
    Process.removeAllProcessGroups();

    //开始监控进程的CPU使用情况
    mProcessCpuThread.start();

    //注册服务
    mBatteryStatsService.publish(mContext);
    mAppOpsService.publish(mContext);
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
}

2.2 ActivityManagerService#setSystemProcess
public void setSystemProcess() {
    try {
        //以下是向ServiceManager注册几个服务
        //AMS
        ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
        //注册进程统计信息的服务
        ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
        //用于打印内存信息用的
        ServiceManager.addService("meminfo", new MemBinder(this));
        //用于输出进程使用硬件渲染方面的信息
        ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
        //用于输出数据库相关的信息
        ServiceManager.addService("dbinfo", new DbBinder(this));
        //MONITOR_CPU_USAGE默认为true
        if (MONITOR_CPU_USAGE) {
            //用于输出进程的CPU使用情况
            ServiceManager.addService("cpuinfo", new CpuBinder(this));
        }
        //注册权限管理服务
        ServiceManager.addService("permission", new PermissionController(this));
        //注册获取进程信息的服务
        ServiceManager.addService("processinfo", new ProcessInfoService(this));
        //1、向PKMS查询package名为“android”的应用的ApplicationInfo
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        //2、调用installSystemApplicationInfo
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
        //3、以下与AMS的进程管理有关
        synchronized (this) {
            ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
            app.persistent = true;
            app.pid = MY_PID;
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            synchronized (mPidsSelfLocked) {
                mPidsSelfLocked.put(app.pid, app);
            }
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked();
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
                "Unable to find android system package", e);
    }
}
       从上面的代码可以看出,AMS的setSystemProcess主要有四个主要的功能:
1、注册一些服务;
2、获取package名为“android”的应用的ApplicationInfo;
3、调用ActivityThread的installSystemApplicationInfo;
4、AMS进程管理相关的操作。
         在这个函数中除了发布一些服务外,主要是: 将framework-res.apk的信息加入到SystemServer对应的LoadedApk中,同时构建SystemServer进程对应的ProcessRecord,

以将SystemServer进程纳入到AMS的管理中。


如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!





版权声明:如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!本文为博主原创文章,转载请注明链接!

对ActivityManagerService的一些认识和学习

Android的三大核心功能是ActivityManagerService.java,WindowManagerService.java和View.java。ActivityManagerServic...

Android后台杀死系列之二:ActivityManagerService与App现场恢复机制

系统如何知道Application被杀死了,Android使用了Linux的oomKiller机制,只是简单的做了个变种,采用分等级的LowmemoryKiller,但这个其实是内核层面的,Lowme...

剖析ActivityManagerService源码,了解广播接收和发送机制(二)

1.简介 “在安卓的广播机制中,用户自定义的Activity或自定义的子类BroadcastReceiver扮演着接收器的角色,Activity本身以及各类系统事件(如有电话拨入)也可以扮演广播发出者...

Android系统启动流程分析之启动应用 - ActivityManagerService

ActivityManagerService(Ams)就是在initAndLoop方法里加载的.那么,看下initAndLoop方法里关于AMS的核心代码. 1.context = Ac...

Android中ActivityManagerService与应用程序(客户端)通信模型分析

今天主要分析下ActivityManagerService(服务端) 与应用程序(客户端)之间的通信模型,在介绍这个通信模型的基础上,再    简单介绍实现这个模型所需要数据类型。   ...

Android4_SRC_分析~ActivityManagerService~图解(一)

OK,从现在开始,我们会一个要点一个要点的把Android目前在开发上比较中要的几个知识点从源码开始详细分析,当然,在这里,我主要的是分析framework层下的代码,今天我给分析是关于Activit...

[Android5.1]ActivityManagerService启动过程分析

ActivityManagerService(简称AMS)是Android系统的关键服务之一。它的主要作用如下: 管理系统中所有Activity的整个生命周期 统一调度各个Activity 内存管...

Android 7.0 ActivityManagerService(1) AMS的启动过程

主要介绍AMS启动过程涉及的主要内容

Android的组件管理(Android N)--ActivityManagerService服务

ActivityManagerService是Android Framework的核心,它管理着Android系统的4大组件:Activity、Service、ContentProvider、Broa...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Context与ActivityManagerService
举报原因:
原因补充:

(最多只允许输入30个字)