Android 10.0 系统服务之ActivityMnagerService-AMS启动流程-[Android取经之路]

摘要:上一节我们讲完了SystemServer的启动过程,这一节接着上一节的步骤,来讲解ActivityManagerService的启动过程。

ActivityManagerService简称AMS,具有管理Activity行为、控制activity的生命周期、派发消息事件、内存管理等功能。

阅读本文大约需要花费40分钟。

文章的内容主要还是从源码进行分析,虽然又臭又长,但是如果想要学习Android系统源码,这是必要走的路,没有捷径。

相对于碎片学习,我更倾向于静下心来花费1个小时认真的学习一段内容。

文章首发微信公众号:IngresGe

专注于Android系统级源码分析,Android的平台设计,欢迎关注我,谢谢!

欢迎关注我的公众号!

[Android取经之路] 的源码都基于Android-Q(10.0) 进行分析

[Android取经之路] 系列文章:

《系统启动篇》

  1. Android系统架构
  2. Android是怎么启动的
  3. Android 10.0系统启动之init进程
  4. Android10.0系统启动之Zygote进程
  5. Android 10.0 系统启动之SystemServer进程
  6. Android 10.0 系统服务之ActivityMnagerService
  7. Android10.0系统启动之Launcher(桌面)启动流程
  8. Android10.0应用进程创建过程以及Zygote的fork流程
  9. Android 10.0 PackageManagerService(一)工作原理及启动流程
  10. Android 10.0 PackageManagerService(二)权限扫描
  11. Android 10.0 PackageManagerService(三)APK扫描
  12. Android 10.0 PackageManagerService(四)APK安装流程

《日志系统篇》

  1. Android10.0 日志系统分析(一)-logd、logcat 指令说明、分类和属性
  2. Android10.0 日志系统分析(二)-logd、logcat架构分析及日志系统初始化
  3. Android10.0 日志系统分析(三)-logd、logcat读写日志源码分析
  4. Android10.0 日志系统分析(四)-selinux、kernel日志在logd中的实现​

《Binder通信原理》

  1. Android10.0 Binder通信原理(一)Binder、HwBinder、VndBinder概要
  2. Android10.0 Binder通信原理(二)-Binder入门篇
  3. Android10.0 Binder通信原理(三)-ServiceManager篇
  4. Android10.0 Binder通信原理(四)-Native-C\C++实例分析
  5. Android10.0 Binder通信原理(五)-Binder驱动分析
  6. Android10.0 Binder通信原理(六)-Binder数据如何完成定向打击
  7. Android10.0 Binder通信原理(七)-Framework binder示例
  8. Android10.0 Binder通信原理(八)-Framework层分析
  9. Android10.0 Binder通信原理(九)-AIDL Binder示例
  10. Android10.0 Binder通信原理(十)-AIDL原理分析-Proxy-Stub设计模式
  11. Android10.0 Binder通信原理(十一)-Binder总结

  《HwBinder通信原理》

  1. HwBinder入门篇-Android10.0 HwBinder通信原理(一)
  2.  HIDL详解-Android10.0 HwBinder通信原理(二)
  3. HIDL示例-C++服务创建Client验证-Android10.0 HwBinder通信原理(三)
  4. HIDL示例-JAVA服务创建-Client验证-Android10.0 HwBinder通信原理(四)
  5. HwServiceManager篇-Android10.0 HwBinder通信原理(五)
  6. Native层HIDL服务的注册原理-Android10.0 HwBinder通信原理(六)
  7. Native层HIDL服务的获取原理-Android10.0 HwBinder通信原理(七)
  8. JAVA层HIDL服务的注册原理-Android10.0 HwBinder通信原理(八)
  9. JAVA层HIDL服务的获取原理-Android10.0 HwBinder通信原理(九)
  10. HwBinder驱动篇-Android10.0 HwBinder通信原理(十)
  11. HwBinder原理总结-Android10.0 HwBinder通信原理(十一)

《编译原理》

  1. 编译系统入门篇-Android10.0编译系统(一)
  2. 编译环境初始化-Android10.0编译系统(二)
  3. make编译过程-Android10.0编译系统(三)
  4. Image打包流程-Android10.0编译系统(四)
  5. Kati详解-Android10.0编译系统(五)

上一节讲解了SystemServer的架构、启动流程以及被Zygote 进程fork的流程,这一节重点讲解ActivityManagerService -AMS 服务是如何启动的。

 

1.概述

上一节我们讲完了SystemServer的启动过程,这一节接着上一节的步骤,来讲解ActivityManagerService的启动过程。

ActivityManagerService简称AMS,具有管理Activity行为、控制activity的生命周期、派发消息事件、内存管理等功能。

 

2.核心源码

 

/frameworks/base/services/java/com/android/server/SystemServer.java
/frameworks/base/core/java/android/app/ActivityThread.java
/frameworks/base/core/java/android/app/Instrumentation.java
/frameworks/base/core/java/android/app/ContextImpl.java
/frameworks/base/core/java/android/app/LoadedApk.java
/frameworks/base/core/java/android/app/Application.java

/frameworks/base/core/java/com/android/server/LocalServices.java
/frameworks/base/services/core/java/com/android/server/ServiceThread.java

/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java
/frameworks/base/services/core/java/com/android/server/wm/RootActivityContainer.java
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

 

3.架构

ActivityManagerService启动共分为以下4个阶段:

阶段1:为SystemSerer进程创建Android运行环境。AMS运行与SystemServer进程中,它的许多工作依赖于该运行环境

createSystemContext() -> new ActvityThread()-->attach ->getSystemContext ->createSystemContext

阶段2:启动AMS,主要进行一些初始化工作

new ActivityManagerService()

start()

阶段3:将SystemServer进程纳入到AMS的进程管理体系中

setSystemProcess() //将framework-res.apk的信息加入到SystemServer进程的LoadedApk中;构建SystemServer进程的ProcessRecord,保存到AMS中,以便AMS进程统一管理

installSystemProvider() //安装SystemServer进程中的SettingsProvider.apk

阶段4:AMS启动完成,通知服务或应用完成后续的工作,或直接启动一些进程

AMS.systemReady() //许多服务或应用进程必须等待AMS完成启动工作后,才能启动或进行一些后续工作;AMS就是在systemReady中,通知或者启动这些等待的服务和应用进程,例如启动桌面等。

 

ActivityManagerService时序图如下

 

4. ActivityManagerService启动流程-源码分析

 

 

 

4.1 SystemServer启动

Zygote进行启动后,第一个Fork出SystemServer进程,SystemServer的启动流程可以参考我之前的文章,这里只分析与AMS相关的启动流程:

  1. 初始化 SystemContext
  2. 创建SystemServiceManager 对象,用来启动后面的服务
  3. 启动系统服务,共分为三种系统服务:系统引导服务(Boot Service)、核心服务(Core Service)和其他服务(Other Service)
  4. 在引导服务(Boot Service)中启动ATM、AMS服务
  5. 在其他服务(Other Service)中完成AMS的最后工作systemReady

源码:

[SystemServer.java]

 

public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
    ...
    //1.初始化 System Context
    createSystemContext(); //参考[4.2]

    //2.创建 SystemServiceManager 对象,用来启动后面的服务
    mSystemServiceManager = new SystemServiceManager(mSystemContext); 
    //参考[4.3]
    mSystemServiceManager.setStartInfo(mRuntimeRestart,
            mRuntimeStartElapsedTime, mRuntimeStartUptime);
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
    ...
    
    //3.启动服务
    startBootstrapServices();  //启动引导服务,参考[4.1.1]
    startCoreServices();       //启动核心服务
    startOtherServices();      //启动其他服务,参考[4.1.2]
    ...
}

4.1.1 [SystemServer.java] startBootstrapServices()

说明:启动引导服务,在其中启动了ATM和AMS服务,通过AMS安装Installer、初始化Power,设置系统进程等。

源码:

 

private void startBootstrapServices() {
    ...
    //启动ActivityTaskManagerService服务,简称ATM,Android10新引入功能,用来管理Activity的启动、调度等功能
    //参考[4.4]
    atm = mSystemServiceManager.startService(
            ActivityTaskManagerService.Lifecycle.class).getService();

    //参考[4.5]
    //启动服务 ActivityManagerService,简称AMS
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(
            mSystemServiceManager, atm);

    //安装Installer
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    
    //初始化PowerManager
    mActivityManagerService.initPowerManagement();
    
    //设置系统进程,参考4.6
    mActivityManagerService.setSystemProcess();
    
}

 

 

4.1.2 [SystemServer.java] startOtherServices

说明:启动其他服务,AMS启动后,完成后续桌面启动等操作

源码:

private void startOtherServices() {
    ...
    //安装SettingsProvider.apk
    mActivityManagerService.installSystemProviders();
    mActivityManagerService.setWindowManager(wm);

    //AMS启动完成,完成后续的工作,例如启动桌面等
    //参考[4.7]
    mActivityManagerService.systemReady(() -> {
        ...
    }, BOOT_TIMINGS_TRACE_LOG);
    ...
}

4.2 System Context初始化

说明: 在SystemServer的run函数中,在启动AMS之前,调用了createSystemContext函,主要用来是初始化 System Context和SystemUi Context,并设置主题

当SystemServer 调用createSystemContext()完毕后,完成以下两个内容:

  1. 得到了一个ActivityThread对象,它代表当前进程 (此时为系统进程) 的主线程; 
  2. 得到了一个Context对象,对于SystemServer而言,它包含的Application运行环境与framework-res.apk有关。

源码:

[SystemServer.java]

private void createSystemContext() {
    ActivityThread activityThread = ActivityThread.systemMain();  //参考[4.2.1]
    
    //获取system context
    mSystemContext = activityThread.getSystemContext();
    //设置系统主题
    mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);

    //获取systemui context
    final Context systemUiContext = activityThread.getSystemUiContext();
    //设置systemUI 主题
    systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}

4.2.1 [ActivityThread.java] systemMain()

说明:systemMain函数主要作用是: 创建ActivityThread对象,然后调用该对象的attach函数。

源码:

[ActivityThread.java]

public static ActivityThread systemMain() {
    // The system process on low-memory devices do not get to use hardware
    // accelerated drawing, since this can add too much overhead to the
    // process.
    if (!ActivityManager.isHighEndGfx()) {
        ThreadedRenderer.disable(true);
    } else {
        ThreadedRenderer.enableForegroundTrimming();
    }
    //获取ActivityThread对象
    ActivityThread thread = new ActivityThread(); //参考[4.2.2]
    thread.attach(true, 0); 参考[4.2.3]
    return thread;
}

 

4.2.2 ActivityThread 对象创建

说明:ActivityThread是Android Framework中一个非常重要的类,它代表一个应用进程的主线程,其职责就是调度及执行在该线程中运行的四大组件。 

注意到此处的ActivityThread创建于SystemServer进程中。 

由于SystemServer中也运行着一些系统APK,例如framework-res.apk、SettingsProvider.apk等,因此也可以认为SystemServer是一个特殊的应用进程。

AMS负责管理和调度进程,因此AMS需要通过Binder机制和应用进程通信。 

为此,Android提供了一个IApplicationThread接口,该接口定义了AMS和应用进程之间的交互函数。

ActivityThread的构造函数比较简单,获取ResourcesManager的单例对象,比较关键的是它的成员变量:

源码:

public final class ActivityThread extends ClientTransactionHandler {

    ...
    //定义了AMS与应用通信的接口,拿到ApplicationThread的对象
    final ApplicationThread mAppThread = new ApplicationThread();

    //拥有自己的looper,说明ActivityThread确实可以代表事件处理线程
    final Looper mLooper = Looper.myLooper();

    //H继承Handler,ActivityThread中大量事件处理依赖此Handler
    final H mH = new H();

    //用于保存该进程的ActivityRecord
    final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();

    //用于保存进程中的Service
    final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();

    用于保存进程中的Application
    final ArrayList<Application> mAllApplications
        = new ArrayList<Application>();
    //构造函数
    @UnsupportedAppUsage
    ActivityThread() {
        mResourcesManager = ResourcesManager.getInstance();
    }
}

4.2.3 [ActivityThread.java] attach

说明:对于系统进程而言,ActivityThread的attach函数最重要的工作就是创建了Instrumentation、Application和Context

调用:attach(true, 0),传入的system为0

源码:

 

private void attach(boolean system, long startSeq) {
    mSystemThread = system;
    //传入的system为0
    if (!system) {
        //应用进程的处理流程
        ...
    } else {
        //系统进程的处理流程,该情况只在SystemServer中处理
        //创建ActivityThread中的重要成员:Instrumentation、 Application 和 Context
        mInstrumentation = new Instrumentation();
        mInstrumentation.basicInit(this);
        
        //创建系统的Context,参考[4.2.4]
        ContextImpl context = ContextImpl.createAppContext(
                this, getSystemContext().mPackageInfo);
        
        //调用LoadedApk的makeApplication函数
        mInitialApplication = context.mPackageInfo.makeApplication(true, null);
        mInitialApplication.onCreate();
    }
    
}

Instrumentation 

Instrumentation是Android中的一个工具类,当该类被启用时,它将优先于应用中其它的类被初始化。 

此时,系统先创建它,再通过它创建其它组件。

mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);

Context

Context是Android中的一个抽象类,用于维护应用运行环境的全局信息。

通过Context可以访问应用的资源和类,甚至进行系统级的操作,例如启动Activity、发送广播等。

ActivityThread的attach函数中,通过下面的代码创建出系统应用对应的Context:

ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);

Application:

Android中Application类用于保存应用的全局状态。

在ActivityThread中,针对系统进程,通过下面的代码创建了初始的Application:

mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();

 

4.2.4 [ContextImpl.java] getSystemContext()

说明:创建并返回System Context

源码:

public ContextImpl getSystemContext() {
    synchronized (this) {
        if (mSystemContext == null) {
            //调用ContextImpl的静态函数createSystemContext
            mSystemContext = ContextImpl.createSystemContext(this);
        }
        return mSystemContext;
    }
}

说明:createSystemContext的内容就是创建一个LoadedApk,然后初始化一个ContextImpl对象。 
注意到createSystemContext函数中,创建的LoadApk对应packageName为”android”,也就是framwork-res.apk。 
由于该APK仅供SystemServer进程使用,因此创建的Context被定义为System Context。 
现在该LoadedApk还没有得到framwork-res.apk实际的信息。
当PKMS启动,完成对应的解析后,AMS将重新设置这个LoadedApk。

static ContextImpl createSystemContext(ActivityThread mainThread) {
    //创建LoadedApk类,代表一个加载到系统中的APK
    //注意此时的LoadedApk只是一个空壳
    //PKMS还没有启动,无法得到有效的ApplicationInfo
    LoadedApk packageInfo = new LoadedApk(mainThread);

    //拿到ContextImpl 的对象
    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;
}

4.3 SystemServiceManager 创建

说明: 通过 SystemServiceManager 的构造方法创建一个 SystemServiceManager 对象,并将该对象添加到 LocalServices 中。

源码:

private void run() {
    ...
    //1.创建SystemServiceManager对象,参考 [4.3.1]
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    mSystemServiceManager.setStartInfo(mRuntimeRestart,
            mRuntimeStartElapsedTime, mRuntimeStartUptime);
    //2.启动SystemServiceManager服务,参考[4.3.2]
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
    ...
}

 

4.3.1 [SystemServiceManager.java] SystemServiceManager()

说明:SystemServiceManager 对象主要用于管理 SystemService 的创建、启动等生命周期,SystemService 类是一个抽象类

在 SystemServiceManager 中都是通过反射创建 SystemService 中对象的,而且在 startService(@NonNull final SystemService service) 方法中,会将 SystemService 添加到 mServices 中,并调用 onStart() 方法

SystemServiceManager构造函数没有多少内容,主要是把传进来的system Context赋值给 mContext,供后续服务创建使用

源码:

public class SystemServiceManager {
    ...
    private final Context mContext;
    private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();
    ...
    SystemServiceManager(Context context) {
        mContext = context;
    }

    public SystemService startService(String className) {
        final Class<SystemService> serviceClass;
        try {
            //通过反射根据类名,拿到类对象
            serviceClass = (Class<SystemService>)Class.forName(className);
        } catch (ClassNotFoundException ex) {
            Slog.i(TAG, "Starting " + className);
            ...
        }
        return startService(serviceClass);
    }

    public <T extends SystemService> T startService(Class<T> serviceClass) {
        try {
            final String name = serviceClass.getName();
            // Create the service.
            final T service;
            ...
                service = constructor.newInstance(mContext);
            ...
            startService(service);
            return service;
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
        }
    }
    
    public void startService(@NonNull final SystemService service) {
        // Register it.
        mServices.add(service);
        // Start it.
        long time = SystemClock.elapsedRealtime();
        try {
            service.onStart();  //调用各个服务中的onStart()方法完成服务启动
        } catch (RuntimeException ex) {
            throw new RuntimeException("Failed to start service " + service.getClass().getName()
                    + ": onStart threw an exception", ex);
        }
    }
}

4.3.2 [LocalServices.java] addService(SystemServiceManager.class, mSystemServiceManager);

说明:把SystemServiceManager的对象加入到本地服务的全局注册表中

源码:

 

public final class LocalServices {
    private LocalServices() {}

    private static final ArrayMap<Class<?>, Object> sLocalServiceObjects =
            new ArrayMap<Class<?>, Object>();

    //返回实现指定接口的本地服务实例对象
    @SuppressWarnings("unchecked")
    public static <T> T getService(Class<T> type) {
        synchronized (sLocalServiceObjects) {
            return (T) sLocalServiceObjects.get(type);
        }
    }

    //将指定接口的服务实例添加到本地服务的全局注册表中
    public static <T> void addService(Class<T> type, T service) {
        synchronized (sLocalServiceObjects) {
            if (sLocalServiceObjects.containsKey(type)) {
                throw new IllegalStateException("Overriding service registration");
            }
            sLocalServiceObjects.put(type, service);
        }
    }

    //删除服务实例,只能在测试中使用。
    public static <T> void removeServiceForTest(Class<T> type) {
        synchronized (sLocalServiceObjects) {
            sLocalServiceObjects.remove(type);
        }
    }
}

4.4 ActivityTaskManagerService 服务启动

说明:ActivityTaskManagerService简称ATM,Android10中引入新功能,用来管理Activity的启动、调度等功能

源码:

private void startBootstrapServices() {
    ...
    //启动ATM
    atm = mSystemServiceManager.startService(
                ActivityTaskManagerService.Lifecycle.class).getService();
    ...
}

4.4.1 ATM服务启动过程

说明:从4.3.1 中我们知道SystemServiceManager.startService最终调用的是启动对象中的onStart方法

因此ATM启动,最终会调用ActivityTaskManagerService.Lifecycle.onStart()来启动ATM服务

源码:

 

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

        public Lifecycle(Context context) {
            super(context);
            //1.创建ActivityTaskManagerService,得到对象,参考[4.4.2]
            mService = new ActivityTaskManagerService(context);
        }

        @Override
        public void onStart() {
            publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
            //2.启动ATM服务,,参考[4.4.3]
            mService.start();
        }
        ...
        public ActivityTaskManagerService getService() {
            return mService;
        }
    }

4.4.2 ActivityTaskManagerService 对象创建

说明:ActivityTaskManagerService简称ATM, Android10新引入功能,用来管理Activity的启动、调度等功能

Android10 中把原先在AMS中activity的管理移动到ATM中

从Android 10的代码路径可以看出,管理Activity的ATM被放入到的wm路径中,这个路径原先归WindowManagerService -WMS控制,谷歌的目的也是希望在将来把activity和window融合在一起,减少冗余代码以及AMS和WMS的协调工作

ATM的路径为:frameworks\base\services\core\java\com\android\server\wm

AMS的路径为:frameworks\base\services\core\java\com\android\server\am

ATM服务提供了AIDL接口供

 

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    final Context mUiContext;
    final ActivityThread mSystemThread;
    final ActivityTaskManagerInternal mInternal;

    //ActivityStackSupervisor 是ATM中用来管理Activity启动和调度的核心类
    public ActivityStackSupervisor mStackSupervisor;
    //Activity 容器的根节点
    RootActivityContainer mRootActivityContainer;
    //WMS 负责窗口的管理
    WindowManagerService mWindowManager;
    
    //这是我们目前认为是"Home" Activity的过程
    WindowProcessController mHomeProcess;
    
    public ActivityTaskManagerService(Context context) {
        //拿到System Context
        mContext = context;  
        mFactoryTest = FactoryTest.getMode();

        //取出的是ActivityThread的静态变量sCurrentActivityThread
        //这意味着mSystemThread与SystemServer中的ActivityThread一致
        mSystemThread = ActivityThread.currentActivityThread();
        
        //拿到System UI Context
        mUiContext = mSystemThread.getSystemUiContext();
        mLifecycleManager = new ClientLifecycleManager();
        //拿到LocalService的对象
        mInternal = new LocalService();
        GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
    }
}

4.4.3 [ActivityTaskManagerService.java] start()

说明:将 ActivityTaskManagerInternal添加到本地服务的全局注册表中,ActivityTaskManagerInternal为抽象类

源码:

private void start() {
    LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

4.5 ActivityManagerService 服务启动

说明:ActivityManagerService简称AMS,在Android 10的版本中,Activity的管理和调度移到ATM中,AMS负责 service,broadcast,provider的管理和调度

源码:

private void startBootstrapServices() {
    ...
    //启动AMS
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
    ...
}

 

4.5.1 AMS服务启动过程

说明:从4.3.1 中我们知道SystemServiceManager.startService最终调用的是启动对象中的onStart方法

因此AMS服务启动,最终会调用ActivityManagerService.Lifecycle.onStart()来启动ATM服务

源码:

 

 

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

    public Lifecycle(Context context) {
        super(context);
        //1.创建ActivityManagerService,得到对象,传入ATM的对象,参考[4.5.2]
        mService = new ActivityManagerService(context, sAtm);
    }

    @Override
    public void onStart() {
        mService.start();
    }
    ...
    public ActivityManagerService getService() {
        return mService;
    }
}

4.5.2 AMS 对象创建

说明:Android10中,Activity的管理和调度放入到ATM中执行,AMS中保留 service,broadcast,provider的管理和调度

构造函数初始化主要工作就是初始化一些变量,供之后的service,broadcast,provider的管理和调度

源码:

 

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
        ...
        //AMS的运行上下文与SystemServer一致
        mContext = systemContext;
        ...
        //取出的是ActivityThread的静态变量sCurrentActivityThread
        //这意味着mSystemThread与SystemServer中的ActivityThread一致
        mSystemThread = ActivityThread.currentActivityThread();
        mUiContext = mSystemThread.getSystemUiContext();

        mHandlerThread = new ServiceThread(TAG,
                THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        
        //处理AMS中消息的主力
        mHandler = new MainHandler(mHandlerThread.getLooper());
        
        //UiHandler对应于Android中的UiThread
        mUiHandler = mInjector.getUiHandler(this);

        //创建 BroadcastQueue 前台广播对象,处理超时时长是 10s
        mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "foreground", foreConstants, false);
        //创建 BroadcastQueue 后台广播对象,处理超时时长是 60s
        mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "background", backConstants, true);
        //创建 BroadcastQueue 分流广播对象,处理超时时长是 60s
        mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
                "offload", offloadConstants, true);
        mBroadcastQueues[0] = mFgBroadcastQueue;
        mBroadcastQueues[1] = mBgBroadcastQueue;
        mBroadcastQueues[2] = mOffloadBroadcastQueue;

        // 创建 ActiveServices 对象,用于管理 ServiceRecord 对象
        mServices = new ActiveServices(this);
        // 创建 ProviderMap 对象,用于管理 ContentProviderRecord 对象
        mProviderMap = new ProviderMap(this);
        
        //得到ATM的对象,调用ATM.initialize
        mActivityTaskManager = atm;
        mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
                DisplayThread.get().getLooper());
        //得到ATM的服务信息
        mAtmInternal = LocalServices.getService(
ActivityTaskManagerInternal.class);

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

4.5.3 [ActivityManagerService.java] start()

说明:start中做了两件事

1)启动 CPU 监控线程,在启动 CPU 监控线程之前,首先将进程复位

2)注册电池状态服务和权限管理服务

源码:

 

private void start() {
    //1.移除所有的进程组
    removeAllProcessGroups();
    //启动 CPU 监控线程
    mProcessCpuThread.start();

    //2.注册电池状态和权限管理服务
    mBatteryStatsService.publish();
    mAppOpsService.publish(mContext);
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    mActivityTaskManager.onActivityManagerInternalAdded();
    mUgmInternal.onActivityManagerInternalAdded();
    mPendingIntentController.onActivityManagerInternalAdded();
    // Wait for the synchronized block started in mProcessCpuThread,
    // so that any other access to mProcessCpuTracker from main thread
    // will be blocked during mProcessCpuTracker initialization.
    try {
        mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
        Slog.wtf(TAG, "Interrupted wait during start", e);
        Thread.currentThread().interrupt();
        throw new IllegalStateException("Interrupted wait during start");
    }
}

4.6 [SystemServer.java] setSystemProcess()

说明:为系统进程设置应用程序实例并开始

源码:

private void startOtherServices() {
     //参考[4.6.1]
     Set up the Application instance for the system process and get started.
     mActivityManagerService.setSystemProcess();
 }

4.6.1 [ActivityManagerService.java] setSystemProcess()

说明:AMS的setSystemProcess主要有五个主要的功能: 

  1. 注册一些服务:包括 activity、procstats、meminfo、gfxinfo、dbinfo、permission、processinfo
  2. 获取package名为“android”的应用的 ApplicationInfo; 
  3. 为ActivityThread 安装 system application相关信息,将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo 
  4. 为systemserver 主进程开辟一个ProcessRecord来维护进程的相关信息
  5. AMS进程管理相关的操作。

源码:

 

public void setSystemProcess() {
  try {
      //1.注册一些服务到ServiceManager:包括 activity、procstats、meminfo、gfxinfo、dbinfo、permission、processinfo
      ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
              DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
      ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
      ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
              DUMP_FLAG_PRIORITY_HIGH);
      ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
      ServiceManager.addService("dbinfo", new DbBinder(this));
      if (MONITOR_CPU_USAGE) {
          ServiceManager.addService("cpuinfo", new CpuBinder(this),
                  /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
      }
      ServiceManager.addService("permission", new PermissionController(this));
      ServiceManager.addService("processinfo", new ProcessInfoService(this));

      //2.通过解析framework-res.apk里的AndroidManifest.xml获得ApplicationInfo
      ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
              "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
      //3.为ActivityThread 安装 system application相关信息,将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo
      mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

       //4.为systemserver 主进程开辟一个ProcessRecord来维护进程的相关信息
      synchronized (this) {
          ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
                  false,
                  0,
                  new HostingRecord("system"));
          app.setPersistent(true); //设置进程常驻
          app.pid = MY_PID;  //为ProcessRecord赋值当前进程ID,即system_server进程ID
          app.getWindowProcessController().setPid(MY_PID);
          app.maxAdj = ProcessList.SYSTEM_ADJ;
          app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
          mPidsSelfLocked.put(app); //将ProcessRecord放到mPidSelfLocked里统一管理
          mProcessList.updateLruProcessLocked(app, false, null);
          updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
      }
  } catch (PackageManager.NameNotFoundException e) {
      throw new RuntimeException(
              "Unable to find android system package", e);
  }

  // Start watching app ops after we and the package manager are up and running.
  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);
                      }
                  }
              }
          });
  }

4.7 完成ActivityManagerService 最后工作[ActivityManagerService.java] systemReady()

说明: AMS的systemReady 处理分为三个阶段

阶段1:主要是调用一些关键服务的初始化函数, 然后杀死那些没有FLAG_PERSISTENT却在AMS启动完成前已经存在的进程, 

同时获取一些配置参数。 需要注意的是,由于只有Java进程才会向AMS注册,而一般的Native进程不会向AMS注册,因此此处杀死的进程是Java进程。

阶段2:执行goingCallback的处理,主要的工作就是通知一些服务可以进行systemReady、systemRunning相关的工作,并进行启动服务或应用进程的工作

阶段3:启动Home Activity,当启动结束,并发送ACTION_BOOT_COMPLETED广播时,AMS的启动过程告一段落

 

源码:

   private void startOtherServices() {
        mActivityManagerService.systemReady(() -> {xxxxxgoingCallbackxxx,
BOOT_TIMINGS_TRACE_LOG);
    }

    public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
        阶段1:关键服务的初始化
        阶段2:goingCallback处理
        阶段3:启动Home Activity,完成AMS启动
    }

 

4.7.1 systemReady 阶段1

说明:主要是调用一些关键服务的初始化函数, 然后杀死那些没有 FLAG_PERSISTENT 却在AMS启动完成前已经存在的进程, 同时获取一些配置参数。 需要注意的是,由于只有Java进程才会向AMS注册,而一般的Native进程不会向AMS注册,因此此处杀死的进程是Java进程。

源码:

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    synchronized(this) {
        //第一次进入mSystemReady 为false,不走该流程
        if (mSystemReady) {
            if (goingCallback != null) {
                goingCallback.run();
            }
            return;
        }

        /** PowerSaveMode_start */
        Settings.System.putInt(mContext.getContentResolver(),
                ActivityTaskManagerService.SUPER_POWER_SAVE_MODE,
                ActivityTaskManagerService.SUPER_POWER_SAVE_MODE_NORMAL);
        /** PowerSaveMode_end */

        //这一部分主要是调用一些关键服务SystemReady相关的函数,
        //进行一些等待AMS初始完,才能进行的工作
        mActivityTaskManager.onSystemReady();
        mUserController.onSystemReady();
        mAppOpsService.systemReady();
        ...
        mSystemReady = true;
    }

    try {
        sTheRealBuildSerial = IDeviceIdentifiersPolicyService.Stub.asInterface(
                ServiceManager.getService(Context.DEVICE_IDENTIFIERS_SERVICE))
                .getSerial();
    } catch (RemoteException e) {}

    ArrayList<ProcessRecord> procsToKill = null;
    synchronized(mPidsSelfLocked) {
        //mPidsSelfLocked 中保存当前正在运行的所有进程的信息
        for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
            ProcessRecord proc = mPidsSelfLocked.valueAt(i);
            //在AMS启动完成前,如果没有FLAG_PERSISTENT标志的进程已经启动了,
            //就将这个进程加入到procsToKill中
            if (!isAllowedWhileBooting(proc.info)){
                if (procsToKill == null) {
                    procsToKill = new ArrayList<ProcessRecord>();
                }
                procsToKill.add(proc);
            }
        }
    }

    //收集已经启动的进程并杀死,排除persistent常驻进程
    synchronized(this) {
        //利用removeProcessLocked关闭procsToKill中的进程
        if (procsToKill != null) {
            for (int i=procsToKill.size()-1; i>=0; i--) {
                ProcessRecord proc = procsToKill.get(i);
                Slog.i(TAG, "Removing system update proc: " + proc);
                mProcessList.removeProcessLocked(proc, true, false, "system update done");
            }
        }
        //至此系统准备完毕
        mProcessesReady = true;
    }
    ...
    mUgmInternal.onSystemReady();

}

4.7.2 systemReady 阶段2

说明:执行goingCallback的处理,主要的工作就是通知一些服务可以进行systemReady相关的工作,并进行启动服务或应用进程的工作

源码:

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    ...
    //1.调用参数传入的runnable对象,SystemServer中有具体的定义,参考[4.7.2.1]
    if (goingCallback != null) goingCallback.run();
    ...
    //调用所有系统服务的onStartUser接口
    mSystemServiceManager.startUser(currentUserId);
    synchronized (this) {
        //启动persistent为1的application所在的进程,参考[4.7.2.2]
        startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
        // Start up initial activity.
        mBooting = true;
        ...
}

4.7.2.1 goingCallback.run()

说明:监控Native的crash,启动WebView,执行一些服务的systemReady 和systemRunning方法

源码:

 

private void startOtherServices() {
  mActivityManagerService.systemReady(() -> {
  //阶段 550
  mSystemServiceManager.startBootPhase(
              SystemService.PHASE_ACTIVITY_MANAGER_READY);
  ...
  //监控Native的crash
  mActivityManagerService.startObservingNativeCrashes();
  , BOOT_TIMINGS_TRACE_LOG);
  ...
  //启动WebView
  mWebViewUpdateService.prepareWebViewInSystemServer();
  //启动systemUI,参考[4.7.2.3]
  startSystemUi(context, windowManagerF);
  
  // 执行一系列服务的systemReady方法
  networkManagementF.systemReady();
  ipSecServiceF.systemReady();
  networkStatsF.systemReady();
  connectivityF.systemReady();
  networkPolicyF.systemReady(networkPolicyInitReadySignal);
  ...
  //阶段 600
  mSystemServiceManager.startBootPhase(
              SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
  
  //执行一系列服务的systemRunning方法
  locationF.systemRunning();
  countryDetectorF.systemRunning();
  networkTimeUpdaterF.systemRunning();
  inputManagerF.systemRunning();
  telephonyRegistryF.systemRunning();
  mediaRouterF.systemRunning();
  mmsServiceF.systemRunning();
  ...
}

4.7.2.2 [ActivityManagerService.java] startPersistentApps

说明:启动persistent为1的application所在的进程

源码:

 

void startPersistentApps(int matchFlags) {
  if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) return;
  
  synchronized (this) {
      try {
           //从PKMS中得到persistent为1的ApplicationInfo
          final List<ApplicationInfo> apps = AppGlobals.getPackageManager()
                  .getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();
          for (ApplicationInfo app : apps) {
               //由于framework-res.apk已经由系统启动,所以此处不再启动它
              if (!"android".equals(app.packageName)) {
                   //addAppLocked中将启动application所在进程 
                  addAppLocked(app, null, false, null /* ABI override */);
              }
          }
      } catch (RemoteException ex) {
      }
  }
}

4.7.2.3 启动systemUI startSystemUi

说明:启动system UI, 启动服务,服务名称”com.android.systemui/.SystemUIService”

源码:

[SystemServer.java]

 

private static void startSystemUi(Context context, WindowManagerService windowManager) {
  Intent intent = new Intent();
  intent.setComponent(new ComponentName("com.android.systemui",
          "com.android.systemui.SystemUIService"));
  intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
  //Slog.d(TAG, "Starting service: " + intent);
  context.startServiceAsUser(intent, UserHandle.SYSTEM);
  windowManager.onSystemUiStarted();
}

4.7.3 systemReady 阶段3

说明:启动Home Activity,当启动结束,并发送ACTION_BOOT_COMPLETED广播时,AMS的启动过程告一段落

源码:

 

public  void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
  ...
  //1.通过ATM,启动Home Activity,参考[4.7.3.1]
  mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
  ...
  //2.发送一些广播消息
  try {
      //system发送广播 ACTION_USER_STARTED = "android.intent.action.USER_STARTED";
      Intent intent = new Intent(Intent.ACTION_USER_STARTED);
      intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
              | Intent.FLAG_RECEIVER_FOREGROUND);
      intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
      broadcastIntentLocked(null, null, intent,
              null, null, 0, null, null, null, OP_NONE,
              null, false, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
              currentUserId);
      //system发送广播 ACTION_USER_STARTING= "android.intent.action.USER_STARTING";
      intent = new Intent(Intent.ACTION_USER_STARTING);
      intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
      intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
      broadcastIntentLocked(null, null, intent,
              null, new IIntentReceiver.Stub() {
                  @Override
                  public void performReceive(Intent intent, int resultCode, String data,
                          Bundle extras, boolean ordered, boolean sticky, int sendingUser)
                          throws RemoteException {
                  }
              }, 0, null, null,
              new String[] {INTERACT_ACROSS_USERS}, OP_NONE,
              null, true, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
              UserHandle.USER_ALL);
      } catch (Throwable t) {
          Slog.wtf(TAG, "Failed sending first user broadcasts", t);
      } finally {
          Binder.restoreCallingIdentity(ident);
  }
}

4.7.3.1 [ActivityTaskManagerService] startHomeOnAllDisplays

说明:启动Home Activity

源码:

[ActivityTaskManagerService.java]

public boolean startHomeOnAllDisplays(int userId, String reason) {
    synchronized (mGlobalLock) {
        //调用RootActivityContainer的startHomeOnAllDisplays(),最终到startHomeOnDisplay()
        return mRootActivityContainer.startHomeOnAllDisplays(userId, reason);
    }
}

[RootActivityContainer.java]

 

boolean startHomeOnDisplay(int userId, String reason, int displayId, boolean allowInstrumenting,
        boolean fromHomeKey) {
    // Fallback to top focused display if the displayId is invalid.
    if (displayId == INVALID_DISPLAY) {
        displayId = getTopDisplayFocusedStack().mDisplayId;
    }

    Intent homeIntent = null;
    ActivityInfo aInfo = null;
    if (displayId == DEFAULT_DISPLAY) {
        //home intent有CATEGORY_HOME
        homeIntent = mService.getHomeIntent();
         //根据intent中携带的ComponentName,利用PKMS得到ActivityInfo
        aInfo = resolveHomeActivity(userId, homeIntent);
    } else if (shouldPlaceSecondaryHomeOnDisplay(displayId)) {
        Pair<ActivityInfo, Intent> info =
                RootActivityContainerMifavor.resolveSecondaryHomeActivityPcMode(this, userId, displayId);
        aInfo = info.first;
        homeIntent = info.second;
    }
    if (aInfo == null || homeIntent == null) {
        return false;
    }

    if (!canStartHomeOnDisplay(aInfo, displayId, allowInstrumenting)) {
        return false;
    }

    // Updates the home component of the intent.
    homeIntent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
    homeIntent.setFlags(homeIntent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
    // Updates the extra information of the intent.
    if (fromHomeKey) {
        homeIntent.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, true);
    }
    // Update the reason for ANR debugging to verify if the user activity is the one that
    // actually launched.
    final String myReason = reason + ":" + userId + ":" + UserHandle.getUserId(
            aInfo.applicationInfo.uid) + ":" + displayId;
    //启动Home Activity--Luncher
    mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
            displayId);
    return true;
}

5.Android10中AMS的一些变化

在Android 10 中安卓为了将来的方案更设计更加明确,对AMS做了很多修改,安卓的最终目的是把activity 和window融合,在Android 10.0上只是简单的代码路径变化,整体逻辑还是跟Android 9.0 类似

Android 10中引入了ActivityTaskManager--ATM的概念。

5.1 Android P 的冗余问题

Android 9.0 及以前版本,Acitivity 管理由AMS 和WMS 协作完成,导致在AMS 和WMS 中都有相似功能的实体,除了大量的代码冗余之外,二者之间的协作也非常困难。

 

5.2 Android 10的变化

  从Android 10.0 的代码变更看,google 最终的目的是把activity 和window融合,目前发布的版本虽然做了大量的代码变更,但和P 之前的版本的流程变化不大,

目前只是简单的把代码整理到一起了,还属于中间状态,按android文档介绍,完全融合在M 甚至更靠后的版本才能完成。

      目前已完成的工作:

  • 把AMS 下面只和activity 管理相关的代码移到WMS的目录下,actvityStack、activityRecord 等文件,全部移到WMS 目录下,和window 统一管理.
  • AMS 中部分文件拆分,把原来activity和其他组件融合在一起处理的文件进行拆分,activity 相关部分单独拆分,移到WMS 中统一管理。比如ActivityManagerService.java 拆分成了ActivityManagerService.java 和ActivityTaskManagerService.java 两个文件,activity 的启动由ActivityTaskManagerService.java 负责:
  • 因为Activity 和window的管理统一由WMS 完成,不再需要之前的DispayWindowController、stackWindowController 来居中协调,可以把display、stack、task 等统一管理。最终要做到完全融合,以stack 为例,完成后会把taskstack的功能完全融合进activityStack,目前只做到了在activityStack 中包含taskstack。创建、管理流程也随之发生变化。

6.总结

AMS的启动主要经历了如下几个阶段:

  • 为SystemServer进程创建Android运行环境,例如System Context
  • 启动AMS,做一些初始化的工作
  • 将SystemServer进程纳入到AMS的进程管理体系中
  • AMS启动完成,通知服务或应用完成后续的工作,调用一些服务的systemReady()方法中,
  • 启动Luncher,完成AMS的启动工作

 

下一节将会讲解Android10.0 Launcher的启动过程,欢迎关注我,谢谢!

微信公众号:IngresGe

  • 31
    点赞
  • 73
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
### 回答1: android 10.0系统应用默认授权是指在android 10.0系统中,部分应用在安装后默认会被授予一些权限,而不需要用户在应用启动后再去手动开启这些权限,这样可以提高用户的使用体验。 android 10.0系统应用默认授权的目的是为了加强应用的安全性,提高用户的隐私保护。应用需要访问某些敏感数据或功能时,用户在使用前需要手动开启权限,这样可以减少恶意应用通过获取用户授权的方式获取用户的私人信息。 在android 10.0系统中,应用默认被授权的权限包括日历、相机、联系人、位置、麦克风、电话、短信、存储空间等。这些权限是应用正常运行所必需的,用户可以在应用管理器中查看和管理应用授权的权限。 尽管android 10.0系统应用默认授权提高了用户的使用体验,但也存在一些风险。如果用户使用的是恶意应用,这些应用也可以默认获取一些敏感权限,从而获取用户的私人信息。因此,用户需要保持对应用的警惕,并仔细审核应用的权限请求。 ### 回答2: 在Android 10.0系统中,应用默认授权是一种新的权限模型。它改变了以往Android系统中权限管理的方式,使用户对应用程序的权限管理更加方便和安全。 传统的权限管理模型通常是一次性处理权限请求,无法区分应用程序对某一项权限的使用情况。这种方式缺少细节和灵活性,可能导致应用程序通过某些权限去访问用户的隐私信息。而Android 10.0系统应用默认授权则可以保护用户的隐私信息和数据安全。 应用默认授权模型允许应用程序在不请求用户手动授权的情况下,自动获得某些权限,并在必要的时候再向用户请求授权。这种方式可以减少用户被安装并包含恶意代码的应用程序所利用的风险。 具体地说,当应用程序请求任何运行时权限时,Android 10.0系统将无法立即授予权限。相反,它将显示一个对话框,询问用户是否要授予权限。只有在用户同意授予权限时,应用程序才能获得此权限。 此外,应用默认授权模型还能够自动限制应用程序对某些权限的访问,比如位置信息和网络数据,除非用户主动授予权限或应用程序已经获得了相应的批准。 总之,Android 10.0系统的应用默认授权能够保护用户隐私,增加应用程序的灵活性,并减少用户遭受来自恶意应用程序的风险。 ### 回答3: Android 10.0系统的应用默认授权,是指所有应用程序在安装时系统会默认授予其部分权限,而不是像以前版本的系统一样需要用户在应用使用时手动授权。 Android 10.0系统应用默认授权的目的,是为了提高应用程序的用户便利性和操作流畅性,同时还可以降低用户在使用应用程序时需要授权的次数。但是这也有可能导致一些应用程序获取用户隐私的风险。 在Android 10.0系统中,应用程序默认被授权的权限包括:网络访问、用户日历、联系人和传感器等。对于其他一些权限,如摄像头、麦克风、存储空间和定位等信息,用户在应用程序使用时需要手动授权才能访问。 因此,用户在使用Android 10.0系统时需要非常谨慎地选择哪些应用程序可以获得自己的隐私权限。建议用户在安装应用程序前,仔细检查其权限请求,尽可能减少不必要的隐私授权操作。 同时,为了更好地保护用户的隐私,Android 10.0系统也提供了更加严格的权限管理功能。用户可以通过设置菜单中的 “应用程序和通知”-“应用程序权限” 来查看和修改应用程序的权限,在此基础上更好地控制应用程序的使用和权限访问。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值