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 对上层应用提供尺度编程接口。
https://img-blog.csdnimg.cn/direct/f15a24778f734704a5874a8b11353c10.png#pic_center
车载 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 可以或许实现对车身的控制与状态的显示。
https://img-blog.csdnimg.cn/direct/5f6dec24bdd04f0e82d5450783f1f681.png#pic_center
Car***Manager:packages/services/Car/car-lib/src/android/car/
Car***Service:packages/services/Car/service/src/com/android/car/
以下列举 CarService 中焦点服务：
Service 端功能Client 端AppFocusService管理同类应用焦点的服务CarAppFocusManagerCarAudioService汽车音频服务CarAudioManagerCarPackageManagerService汽车包管理服务CarPackageManagerCarDiagnosticService汽车诊断服务CarDiagnosticManagerCarPowerManagerService汽车电源管理服务CarPowerManagerIInstrumentClusterManagerServcie仪表服务IInstrumentClusterManagerCarProjecitonService投屏服务CarProjecitonManagerVmsSubscriberService车辆地图服务VmsSubscriberManagerCarBluetoothService汽车蓝牙服务CarBluetoothManagerCarStorageMonitoringService汽车存储监控服务CarStorageMonitoringManagerCarDrivingStateService汽车驾驶状态服务CarDrivingStateManagerCarUXRestrictionsService汽车用户体验限定服务CarUXRestrictionsManagerCarConfigurationService汽车配置服务CarConfigurationManagerCarTrustedDeviceService授信设备管理CarTrustAgentEnrollmentManagerCarMediaService媒体管理服务CarMediaManagerCarBugreportManagerService错误陈诉服务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<String, FeatureInfo> 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
<permissions>
<!-- Feature to specify if the device is a car -->
<feature name="android.hardware.type.automotive" />
.....
</permission>
源码路径：frameworks/native/data/etc/android.hardware.type.automotive.xml
<!-- These features determine that the device running android is a car. -->
<permissions>
<feature name="android.hardware.type.automotive" />
</permissions>
第二步：创建 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<SystemService> 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
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
package="com.android.car"
coreApp="true"
android:sharedUserId="android.uid.system">
......
<application android:label="@string/app_title"
android:directBootAware="true"
android:allowBackup="false"
android:persistent="true">
<service android:name=".CarService"
android:singleUser="true"
android:exported="true">
<intent-filter>
<action android:name="android.car.ICar"/>
</intent-filter>
</service>
......
</application>
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<CarServiceBase> 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的启动时序如下所示：
https://img-blog.csdnimg.cn/direct/c6471ce63b814e5e80142843f042dfa2.png#pic_center
四 总结
本文讲解了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 解析
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]