行业知识
Android 车载应用开发指南（4）- CarService 详解
Android 车载应用开发指南系列文章
Android 车载应用开发指南（1）- 车载操作系统全解析
Android 车载应用开发指南（2）- 应用开发入门
Android 车载应用开发指南（3）- SystemUI 详解
Android 车载应用开发指南（4）- CarService 详解
Android 车载应用开发指南（5）- CAN Bus 协议详解
Android 车载应用开发指南（6）- 汽车混动技术简介
一 概述
CarService 是车载 Android 操作系统 Android Automotive OS（下文简介 AAOS）的核心服务之一，所有车载相关的应用都需要通过 CarService 来查询、控制整车的状态，不仅仅是车辆控制，实际上 CarService 几乎就是整个车载 Framework 最核心的组件。
二 CarService 架构
2.1 简介
AAOS 并没有大刀阔斧的改变 Android 原有的整体架构，几乎所有的核心服务 (AMS、WMS、PMS) 与手机并无区别，采用的是同一套源代码，所以我们可以将 AAOS 理解为 Android OS + Automotive Services + Automotive APPs 。
传统的手机系统加上相关的汽车服务，构成了现在的 AAOS，而其中 CarService 就是提供汽车相关功能的最主要的模块。
AAOS 定义了标准的硬件抽象层 HAL(Hardware Abstraction Layer) 来规范各个子系统与 Framework 的调用接口，并且通过 CarService 以及相关的 Car API 对上层应用提供标准编程接口。
车载 HAL 与 AAOS 架构：
- Car App： 包括 OEM 和第三方开发的 App
- Car API： 内有包含 CarSensorManager 在内的 API。位于 /packages/services/Car/car-lib
- CarService： 系统中与车相关的服务。位于 /packages/services/Car
- Vehicle HAL： 汽车的硬件抽象层描述。位于 /hardware/interfaces/automotive/vehicle/2.0/default/impl/vhal_v2_0
2.2 CarService 组成
CarService 源码位置：/packages/services/Car
其目录结构如下所示：
. ├── Android.mk ├── apicheck.mk ├── apicheck_msg_current.txt ├── apicheck_msg_last.txt ├── car-cluster-logging-renderer //LoggingClusterRenderingService 继承 InstrumentClusterRenderingService ├── car-default-input-service //按键消息处理 ├── car-lib //提供给汽车 App 特有的接口，许多定制的模块都在这里实现，包括 Sensor,HVAC,Cabin,ActiveParkingAssiance,Diagnostic,Vendor 等 ├── car-maps-placeholder //地图软件相关 ├── car_product //系统编译相关 ├── car-support-lib //android.support.car ├── car-systemtest-lib //系统测试相关 ├── car-usb-handler //开机自启，用于管理车机 USB ├── CleanSpec.mk ├── evs ├── obd2-lib ├── PREUPLOAD.cfg ├── procfs-inspector ├── service //com.android.car 是一个后台运行的组件，可以长时间运行并且不需要和用户去交互的，这里即使应用被销毁，它也可以正常工作 ├── tests ├── tools //是一系列的工具，要提到的是里面的 emulator，测试需要用到的。python 写的，通过 adb 可以连接 vehicleHal 的工具，用于模拟测试 ├── TrustAgent └── vehicle-hal-support-lib
Android 通信模式通常基于 C/S 模式，即有客户端和服务端，每个服务有对应的代理对象（比如 ActivityManager 相对服务 AMS，就是客户端）。
对于 CarService 也是采用了 C/S 模式，Car App 并不会直接通过 CarService 的实例调用相关功能，而是通过对应的 Car API 完成对服务的调用。这里的 CarService 就是服务端，Car API 就是客户端。
Android 原生 CarService 包含了许多功能服务： Car ** Service（C/S 模式中的服务端）它们与 HAL 层的 VehicleHAL 通信，进而通过车载总线（例如 CAN 总线）与车身进行通讯，同时它们还通过 Car API：Car ** Manger（C/S 模式中的客户端）为应用层的 Car App 提供接口，从而让 App 能够实现对车身的控制与状态的显示。
Car***Manager:packages/services/Car/car-lib/src/android/car/
Car***Service:packages/services/Car/service/src/com/android/car/
以下列举 CarService 中核心服务：
Service 端 功能 Client 端 AppFocusService 管理同类应用焦点的服务 CarAppFocusManager CarAudioService 汽车音频服务 CarAudioManager CarPackageManagerService 汽车包管理服务 CarPackageManager CarDiagnosticService 汽车诊断服务 CarDiagnosticManager CarPowerManagerService 汽车电源管理服务 CarPowerManager IInstrumentClusterManagerServcie 仪表服务 IInstrumentClusterManager CarProjecitonService 投屏服务 CarProjecitonManager VmsSubscriberService 车辆地图服务 VmsSubscriberManager CarBluetoothService 汽车蓝牙服务 CarBluetoothManager CarStorageMonitoringService 汽车存储监控服务 CarStorageMonitoringManager CarDrivingStateService 汽车驾驶状态服务 CarDrivingStateManager CarUXRestrictionsService 汽车用户体验限制服务 CarUXRestrictionsManager CarConfigurationService 汽车配置服务 CarConfigurationManager CarTrustedDeviceService 授信设备管理 CarTrustAgentEnrollmentManager CarMediaService 媒体管理服务 CarMediaManager CarBugreportManagerService 错误报告服务 CarBugreportManager 2.3 使用 CarService
说明：本文源码分析基于版本：android-12.0.0_r3
前文提到，CarService 需要通过 Car API 为应用层提供接口，所以应用开发者只需要知道如何使用 Car API。
第一步：判断平台是否支持车载功能
APP 层在调用 Car API 之前首先会调用 PMS 中的 hasSystemFeature() 方法判断设备是否支持车载功能
if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) { ..... }源码路径：frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
@GuardedBy("mAvailableFeatures") final ArrayMap mAvailableFeatures; @Override public boolean hasSystemFeature(String name, int version) { // allow instant applications synchronized (mAvailableFeatures) { final FeatureInfo feat = mAvailableFeatures.get(name); if (feat == null) { return false; } else { return feat.version >= version; } } }mAvailableFeatures 里面的内容是通过读取/system/etc/permissions下面的 xml 文件（对应 SDK 的位置—frameworks/native/data/etc 下的 XML 文件中的 feature 字段）
源码路径：frameworks/native/data/etc/car_core_hardware.xml
.....
源码路径：frameworks/native/data/etc/android.hardware.type.automotive.xml
第二步：创建 Car 对象，获取 Manager
Car 作为汽车平台最高等级的 API（packages/services/Car/car-lib/src/android/car/Car.java），为外界提供汽车所有服务和数据的访问
- 通过createCar()方法新建 Car 实例
- 成功连接时可以通过getCarManager方法获取相关的 Manager 实例。比如 Hvac 通过 getCarManager 方法获取了一个 CarHvacManager，当获取到 manager 后就可以进行相关操作
// 创建 Car 实例 Car carApiClient = Car.createCar(context); // 获取 CarHvacManager CarHvacManager manager = (CarHvacManager) mCarApiClient.getCarManager(Car.HVAC_SERVICE);
// 调用 disconnect() 断开连接 carApiClient.disconnect();
三 CarService 实现原理
想要弄清楚CarService实现方式，首先需要搞明白CarService的启动流程。
CarService 启动流程主要分为以下四个步骤：
- SystemServer 启动 CarServiceHelperService 服务
- 在调用 startService() 后，CarServiceHelperService 的 onStart() 方法通过 bindService 的方式启动 CarService（一个系统级别的 APK，位于 system/priv-app）
- 启动 CarService 后首先调用 onCreate()，创建 ICarImpl 对象并初始化，在此时创建了一系列 Car 相关的核心服务，并遍历 init 初始化
- 然后调用 onBind 将该 ICarImpl 对象返回给 CarServiceHelperService，CarServiceHelperService 在内部的一个 Binder 对象 ICarServiceHelperImpl传递给 CarService，建立双向跨进程
3.1 启动 CarServiceHelperService 服务
SystemServer会在startOtherServices()方法中让SystemServiceManager先通过反射的形式创建出StartCarServiceHelperService对象。
源码路径：frameworks/base/services/java/com/android/server/SystemServer.java
private void startOtherServices(@NonNull TimingsTraceAndSlog t) { ... // 仅在 automotive 中启动 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) { t.traceBegin("StartCarServiceHelperService"); final SystemService cshs = mSystemServiceManager .startService(CAR_SERVICE_HELPER_SERVICE_CLASS); if (cshs instanceof Dumpable) { mDumper.addDumpable((Dumpable) cshs); } if (cshs instanceof DevicePolicySafetyChecker) { dpms.setDevicePolicySafetyChecker((DevicePolicySafetyChecker) cshs); } t.traceEnd(); } ... }然后在SystemServiceManager中调用StartCarServiceHelperService的onStart()方法。
CarServiceHelperService是CarService的 SystemService 端的配套服务。
源码路径： frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public SystemService startService(String className) { final Class serviceClass = loadClassFromLoader(className, this.getClass().getClassLoader()); return startService(serviceClass); } public void startService(@NonNull final SystemService service) { // Register it. mServices.add(service); long time = SystemClock.elapsedRealtime(); try { service.onStart(); } catch (RuntimeException ex) { throw new RuntimeException("Failed to start service " + service.getClass().getName() + ": onStart threw an exception", ex); } warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart"); } 3.2 绑定 CarService 服务
源码路径： frameworks/opt/car/services/src/com/android/internal/car/CarServiceHelperService.java
private static final String CAR_SERVICE_INTERFACE = "android.car.ICar"; @Override public void onStart() { EventLog.writeEvent(EventLogTags.CAR_HELPER_START); IntentFilter filter = new IntentFilter(Intent.ACTION_REBOOT); filter.addAction(Intent.ACTION_SHUTDOWN); mContext.registerReceiverForAllUsers(mShutdownEventReceiver, filter, null, null); mCarWatchdogDaemonHelper.addOnConnectionChangeListener(mConnectionListener); mCarWatchdogDaemonHelper.connect(); Intent intent = new Intent(); intent.setPackage("com.android.car"); // 绑定包名，设置广播仅对该包有效 intent.setAction(CAR_SERVICE_INTERFACE); // 绑定 action，表明想要启动能够响应设置的这个 action 的活动，并在清单文件 AndroidManifest.xml 中设置 action 属性 // 绑定后回调 if (!mContext.bindServiceAsUser(intent, mCarServiceConnection, Context.BIND_AUTO_CREATE, mHandler, UserHandle.SYSTEM)) { Slogf.wtf(TAG, "cannot start car service"); } loadNativeLibrary(); }源码路径：packages/services/Car/service/AndroidManifest.xml
sharedUserId 是系统级别的，类似 SystemUI，它编译出来同样是一个 APK 文件
设备文件路径： /system/priv-app/CarService/CarService.apk
...... ......
3.3 CarService 初始化
CarService进入启动时序后，会在onCreate()方法中进行一系列自身的初始化操作，步骤如下：
1）通过 HIDL 接口获取到 HAL 层的 IHwBinder 对象IVehicle，与 AIDL 的用法类似，必须持有 IHwBinder 对象我们才可以与 Vehicle HAL 层进行通信。
2）创建 ICarImpl 对象，并调用init方法，它就是ICar.aidl接口的实现类，我们需要通过它才能拿到其他的 Service 的 IBinder 对象。
3）将ICar.aidl的实现类添加到 ServiceManager 中。
4）设定 SystemProperty，将CarService设定为创建完成状态，只有包含CarService在内的所有的核心 Service 都完成初始化，才能结束开机动画并发送开机广播。
源码路径：packages/services/Car/service/src/com/android/car/CarService.java
@Override public void onCreate() { LimitedTimingsTraceLog initTiming = new LimitedTimingsTraceLog(CAR_SERVICE_INIT_TIMING_TAG, Trace.TRACE_TAG_SYSTEM_SERVER, CAR_SERVICE_INIT_TIMING_MIN_DURATION_MS); initTiming.traceBegin("CarService.onCreate"); initTiming.traceBegin("getVehicle"); // 获取 hal 层的 Vehicle service mVehicle = getVehicle(); initTiming.traceEnd(); ... //创建 ICarImpl 实例 mICarImpl = new ICarImpl(this, mVehicle, SystemInterface.Builder.defaultSystemInterface(this).build(), mVehicleInterfaceName); //然后调用 ICarImpl 的 init 初始化方法 mICarImpl.init(); linkToDeath(mVehicle, mVehicleDeathRecipient); //将该 service 注册到 ServiceManager ServiceManager.addService("car_service", mICarImpl); //设置 boot.car_service_created 属性 SystemProperties.set("boot.car_service_created", "1"); super.onCreate(); initTiming.traceEnd(); // "CarService.onCreate" } @Nullable private static IVehicle getVehicle() { final String instanceName = SystemProperties.get("ro.vehicle.hal", "default"); try { //该 service 启动文件 hardware/interfaces/automotive/vehicle/2.0/default/android.hardware.automotive.vehicle@2.0-service.rc return android.hardware.automotive.vehicle.V2_0.IVehicle.getService(instanceName); } catch (RemoteException e) { Slog.e(CarLog.TAG_SERVICE, "Failed to get IVehicle/" + instanceName + " service", e); } catch (NoSuchElementException e) { Slog.e(CarLog.TAG_SERVICE, "IVehicle/" + instanceName + " service not registered yet"); } return null; }接着再看ICarImpl的实现，如下所示：
1）创建各个核心服务对象
2）把服务对象缓存到 CarLocalServices 中，这里主要是为了方便 Service 之间的相互访问
源码路径：/packages/services/Car/service/src/com/android/car/ICarImpl.java
@VisibleForTesting ICarImpl(Context serviceContext, IVehicle vehicle, SystemInterface systemInterface, String vehicleInterfaceName, @Nullable CarUserService carUserService, @Nullable CarWatchdogService carWatchdogService, @Nullable ICarPowerPolicySystemNotification powerPolicyDaemon) { ... mContext = serviceContext; mSystemInterface = systemInterface; CarLocalServices.addService(SystemInterface.class, mSystemInterface); //创建 VehicleHal 对象 mHal = constructWithTrace(t, VehicleHal.class, () -> new VehicleHal(serviceContext, vehicle)); ... // 创建核心服务对象，并缓存到 CarLocalServices mCarPropertyService = constructWithTrace(t, CarPropertyService.class, () -> new CarPropertyService(serviceContext, mHal.getPropertyHal())); mCarDrivingStateService = constructWithTrace(t, CarDrivingStateService.class,() -> new CarDrivingStateService(serviceContext, mCarPropertyService)); mCarUXRestrictionsService = constructWithTrace(t, CarUxRestrictionsManagerService.class, () -> new CarUxRestrictionsManagerService(serviceContext, mCarDrivingStateService, mCarPropertyService)); ... // 将创建的服务对象依次添加到一个 list 中保存起来 List allServices = new ArrayList(); allServices.add(mFeatureController); allServices.add(mCarUXRestrictionsService); // mCarUserService depends on it allServices.add(mCarUserService); allServices.add(mSystemActivityMonitoringService); allServices.add(mCarPowerManagementService); allServices.add(mCarPropertyService); allServices.add(mCarDrivingStateService); allServices.add(mCarOccupantZoneService); addServiceIfNonNull(allServices, mOccupantAwarenessService); allServices.add(mCarPackageManagerService); allServices.add(mCarInputService); allServices.add(mGarageModeService); ... } @MainThread void init() { LimitedTimingsTraceLog t = new LimitedTimingsTraceLog(CAR_SERVICE_INIT_TIMING_TAG, Trace.TRACE_TAG_SYSTEM_SERVER, CAR_SERVICE_INIT_TIMING_MIN_DURATION_MS); t.traceBegin("ICarImpl.init"); t.traceBegin("VHAL.init"); mHal.init(); t.traceEnd(); t.traceBegin("CarService.initAllServices"); //启动的所有服务遍历调用 init 初始化（各个都继承了 CarServiceBase） for (CarServiceBase service : mAllServices) { t.traceBegin(service.getClass().getSimpleName()); service.init(); t.traceEnd(); } t.traceEnd(); // "CarService.initAllServices" t.traceEnd(); // "ICarImpl.init" }然后将上面 onCreate() 创建的 mICarImpl 对象返回：
- onBind() 回调方法会继续传递通过 bindService() 传递来的 intent 对象（即上面的bindServiceAsUser方法）
- onUnbind() 会处理传递给 unbindService() 的 intent 对象。如果 service 允许绑定，onBind() 会返回客户端与服务互相联系的通信句柄
源码路径：/packages/services/Car/service/src/com/android/car/CarService.java
@Override public IBinder onBind(Intent intent) { return mICarImpl; }所以此处的 mICarImpl 会作为 IBinder 返回给CarServiceHelperService.java - bindServiceAsUser方法中的参数 mCarServiceConnection（回调）
3.4 回调 ServiceConnection
ICarImpl 初始化完毕，会作为 IBinder 返回给CarServiceHelperService.java - bindServiceAsUser方法中绑定此服务的 mCarServiceConnection（回调）
mCarServiceConnection 初始化如下：
- 其中返回的 ICarImpl 被保存在了 CarServiceHelperService 的 mCarService
- mCarService.transact 跨进程通信，调用 ICar.aidl 中定义的第一个方法 setCarServiceHelper
源码路径：/frameworks/opt/car/services/src/com/android/internal/car/CarServiceHelperService.java
private static final String CAR_SERVICE_INTERFACE = "android.car.ICar"; private IBinder mCarService; private final ICarServiceHelperImpl mHelper = new ICarServiceHelperImpl(); private final ServiceConnection mCarServiceConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName componentName, IBinder iBinder) { if (DBG) { Slogf.d(TAG, "onServiceConnected: %s", iBinder); } handleCarServiceConnection(iBinder); } @Override public void onServiceDisconnected(ComponentName componentName) { handleCarServiceCrash(); } }; @VisibleForTesting void handleCarServiceConnection(IBinder iBinder) { synchronized (mLock) { if (mCarServiceBinder == iBinder) { return; // already connected. } Slogf.i(TAG, "car service binder changed, was %s new: %s", mCarServiceBinder, iBinder); //1. 返回的 ICarImpl 被保存在了 CarServiceHelperService 的 mCarServiceBinder mCarServiceBinder = iBinder; Slogf.i(TAG, "**CarService connected**"); } sendSetSystemServerConnectionsCall(); ... } private void sendSetSystemServerConnectionsCall() { Parcel data = Parcel.obtain(); data.writeInterfaceToken(CAR_SERVICE_INTERFACE); data.writeStrongBinder(mHelper.asBinder()); //将 ICarServiceHelperImpl 类型的对象作为数据跨进程传递 data.writeStrongBinder(mCarServiceConnectedCallback.asBinder()); IBinder binder; synchronized (mLock) { binder = mCarServiceBinder; } int code = IBinder.FIRST_CALL_TRANSACTION; try { //2. 跨进程传输 //对端是 mCarService 即 ICarImpl，调用 binder 的 transact 进行跨进程通信 //其 code 代表需要调用的对端方法，data 为携带的传输数据 //FIRST_CALL_TRANSACTION = 0x00000001，即调用对端 ICar.aidl 中定义的第一个方法 setCarServiceHelper if (VERBOSE) Slogf.v(TAG, "calling one-way binder transaction with code %d", code); // oneway void setSystemServerConnections(in IBinder helper, in IBinder receiver) = 0; binder.transact(code, data, null, Binder.FLAG_ONEWAY); if (VERBOSE) Slogf.v(TAG, "finished one-way binder transaction with code %d", code); } ... }跨进程 setSystemServerConnections
@Override public void setSystemServerConnections(IBinder helper, IBinder receiver) { Bundle bundle; try { EventLog.writeEvent(EventLogTags.CAR_SERVICE_SET_CAR_SERVICE_HELPER, Binder.getCallingPid()); assertCallingFromSystemProcess(); //将 ICarServiceHelper 的代理端保存在 ICarImpl 内部 mICarServiceHelper ICarServiceHelper carServiceHelper = ICarServiceHelper.Stub.asInterface(helper); synchronized (mLock) { mICarServiceHelper = carServiceHelper; } //同时也传给了 SystemInterface //此时他们有能力跨进程访问 CarServiceHelperService mSystemInterface.setCarServiceHelper(carServiceHelper); mCarOccupantZoneService.setCarServiceHelper(carServiceHelper); mCarUserService.setCarServiceHelper(carServiceHelper); ... }3.5 小结
CarService的启动时序如下所示：
四 总结
本文讲解了CarService的总体结构、使用方法及启动流程。CarService中实现的功能非常庞大，可以说相比传统手机端的 Android 系统，AAOS 中独特且最重要的部分都在 Framework 的CarService中。
- 首先 CarService 是一个系统级别的服务 APK，类似 SystemUI，其在开机时由 SystemServer 通过 CarServiceHelperService 启动。
- CarServiceHelperService 通过绑定服务的方式启动 CarService，启动之后创建了一个 Binder 对象 ICarImpl，并通过 onBind 返回给 system_server 进程。
- ICarImpl 构造方法中创建了一系列和汽车相关的核心服务，并依次启动这些服务即调用各自 init 方法。ICarImpl 返回给 CarServiceHelperService 之后，CarServiceHelperService 也将其内部的一个 Binder 对象（ICarServiceHelperImpl）传递到了 CarService 进程，自此 CarService 和 system_server 两个进程建立了双向 Binder 通信。
- ICarImpl 返回给 CarServiceHelperService 之后，CarServiceHelperService 也将其内部的一个 Binder 对象（ICarServiceHelperImpl）传递到了 CarService 进程，自此 CarService 和 system_server 两个进程建立了双向 Binder 通信。
五 参考
Android carservice 架构及启动流程
【Android R】车载 Android 核心服务 - CarService 解析
