Android Automotive（五） CarService
CarService是Android Automotive在系统框架层的核心服务。它类似SystemServer在服务内部管理着数十个子服务。
启动流程
CarService是由SystemServer启动的，启动流程如下。
- SystemServer 启动CarServiceHelperService
- CarServiceHelperService绑定CarService
- CarService创建ICarImpl实例，调用init方法
- ICarImpl启动其它服务
SystemServer代码:frameworks/base/services/java/com/android/server/SystemServer.java
private static final String CAR_SERVICE_HELPER_SERVICE_CLASS =
"com.android.internal.car.CarServiceHelperService";
private void startOtherServices() {
mActivityManagerService.systemReady(() -> {
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
traceBeginAndSlog("StartCarServiceHelperService");
mSystemServiceManager.startService(CAR_SERVICE_HELPER_SERVICE_CLASS);
traceEnd();
}
});
}
CarServiceHelperService代码：frameworks/opt/car/services/src/com/android/internal/car/CarServiceHelperService.java
private static final String CAR_SERVICE_INTERFACE = "android.car.ICar";
public class CarServiceHelperService extends SystemService {
@Override
public void onStart() {
Intent intent = new Intent();
intent.setPackage("com.android.car");
intent.setAction(CAR_SERVICE_INTERFACE);
if (!getContext().bindServiceAsUser(intent, mCarServiceConnection, Context.BIND_AUTO_CREATE, UserHandle.SYSTEM)) {
Slog.wtf(TAG, "cannot start car service");
}
System.loadLibrary("car-framework-service-jni");
}
}
SystemServer中ActivityManagerService.systemReady后会通过SystemServiceManager启动CarServiceHelperServiceCarServiceHelperService中绑定CarService
CarService清单文件：packages/services/Car/service/AndroidManifest.xml
<service android:name=".CarService"
android:singleUser="true">
<intent-filter>
<action android:name="android.car.ICar" />
</intent-filter>
</service>
- 通过在
CarService的AndroidManifest的配置，CarServiceHelperService可以通过包名和action的名称实现和CarService绑定。
CarService代码：packages/services/Car/service/src/com/android/car/CarService.java
private ICarImpl mICarImpl;
private IVehicle mVehicle;
@Override
public void onCreate() {
Log.i(CarLog.TAG_SERVICE, "Service onCreate");
mCanBusErrorNotifier = new CanBusErrorNotifier(this /* context */);
mVehicle = getVehicle();
EventLog.writeEvent(EventLogTags.CAR_SERVICE_CREATE, mVehicle == null ? 0 : 1);
Log.i(CarLog.TAG_SERVICE, "Connected to " + mVehicleInterfaceName);
EventLog.writeEvent(EventLogTags.CAR_SERVICE_CONNECTED, mVehicleInterfaceName);
mICarImpl = new ICarImpl(this,
mVehicle,
SystemInterface.Builder.defaultSystemInterface(this).build(),
mCanBusErrorNotifier,
mVehicleInterfaceName);
mICarImpl.init();
linkToDeath(mVehicle, mVehicleDeathRecipient);
ServiceManager.addService("car_service", mICarImpl);
SystemProperties.set("boot.car_service_created", "1");
super.onCreate();
}
@Override
public IBinder onBind(Intent intent) {
return mICarImpl;
}
- CarService中有两个重要的变量，mICarImpl和mVehicle
- mICarImpl是实现ICar接口的AIDL服务端，用于和应用层通信
- mVehicle是实现HIDL的VehicleHal服务接口，用于同hal层通信
ICarImpl代码：packages/services/Car/service/src/com/android/car/ICarImpl.java
private final VehicleHal mHal;
@VisibleForTesting
ICarImpl(Context serviceContext, IVehicle vehicle, SystemInterface systemInterface,
CanBusErrorNotifier errorNotifier, String vehicleInterfaceName,
@Nullable CarUserService carUserService,
@Nullable CarWatchdogService carWatchdogService) {
mContext = serviceContext;
mSystemInterface = systemInterface;
mHal = new VehicleHal(serviceContext, vehicle);
allServices.add(mCarWatchdogService);
// Always put mCarExperimentalFeatureServiceController in last.
addServiceIfNonNull(allServices, mCarExperimentalFeatureServiceController);
mAllServices = allServices.toArray(new CarServiceBase[allServices.size()]);
}
@MainThread
void init() {
mBootTiming = new TimingsTraceLog(VHAL_TIMING_TAG, Trace.TRACE_TAG_HAL);
traceBegin("VehicleHal.init");
mHal.init();
traceEnd();
traceBegin("CarService.initAllServices");
for (CarServiceBase service : mAllServices) {
service.init();
}
traceEnd();
}
ICarImpl中的第一件事就是创建VehicleHal对象，VehicleHal类是CarService中对Vehicle Service的封装，所有的和VehicleHal的交互都在这里处理。并且这里还初始化了其它hal服务。如:PowerHalServiceICarImpl会创建所有的服务，然后将服务添加到CarLocalServices和mAllServices变量中，mAllServices后面在init会用到。init方法调用VehicleHal的init方法初始化mHal.init()init方法会遍历mAllServices中的服务，调用每个服务的init方法进行初始化.
架构
CarSevice
代码路径：packages/services/Car/service/src/com/android/car/CarService.java
CarService作为服务的入库，实际做的事情也不是很多，主要如下。
-
创建服务进程
这个是Android架构的特性，CarService继承了Service，可以作为一个服务在系统后台运行。 -
创建CrashTracker
如果Vehicle hal在10分钟内发生10次Crash，则在CarService抛出异常。private final CrashTracker mVhalCrashTracker = new CrashTracker( 10, // Max crash count. 10 * 60 * 1000, // 10 minutes - sliding time window. () -> { if (IS_USER_BUILD) { Log.e(CarLog.TAG_SERVICE, "Vehicle HAL keeps crashing, notifying user..."); mCanBusErrorNotifier.reportFailure(CarService.this); } else { throw new RuntimeException( "Vehicle HAL crashed too many times in a given time frame"); } } ) -
获取IVehicle实例
IVehicle是HIDL的接口，通过该实例来完成和HAL层的通信 -
完成子服务的创建，初始化子服务。
public void onCreate() {
Log.i(CarLog.TAG_SERVICE, "Service onCreate");
mCanBusErrorNotifier = new CanBusErrorNotifier(this /* context */);
mVehicle = getVehicle();
EventLog.writeEvent(EventLogTags.CAR_SERVICE_CREATE, mVehicle == null ? 0 : 1);
Log.i(CarLog.TAG_SERVICE, "Connected to " + mVehicleInterfaceName);
EventLog.writeEvent(EventLogTags.CAR_SERVICE_CONNECTED, mVehicleInterfaceName);
mICarImpl = new ICarImpl(this,
mVehicle,
SystemInterface.Builder.defaultSystemInterface(this).build(),
mCanBusErrorNotifier,
mVehicleInterfaceName);
mICarImpl.init();
linkToDeath(mVehicle, mVehicleDeathRecipient);
ServiceManager.addService("car_service", mICarImpl);
SystemProperties.set("boot.car_service_created", "1");
super.onCreate();
}
-
mVehicle = getVehicle();获取硬件抽象层的VehicleService实例，getService相对于老版本，增加了String参数。private static IVehicle getVehicle() { final String instanceName = SystemProperties.get("ro.vehicle.hal", "default"); try { return android.hardware.automotive.vehicle.V2_0.IVehicle.getService(instanceName); } catch (RemoteException e) { Log.e(CarLog.TAG_SERVICE, "Failed to get IVehicle/" + instanceName + " service", e); } catch (NoSuchElementException e) { Log.e(CarLog.TAG_SERVICE, "IVehicle/" + instanceName + " service not registered yet"); } return null; } -
mICarImpl = new ICarImpl(this创建ICarImpl对象，相当于是CarService的代理，所有的服务加载和管理都是由它来完成的。 -
mICarImpl.init()完成子服务的初始化 -
linkToDeath(mVehicle, mVehicleDeathRecipient);监听VehicleService的进程状态。 -
ServiceManager.addService("car_service", mICarImpl);将自身加入到ServiceManager供其他模块获取
ICarImpl
代码路径：
packages/services/Car/service/src/com/android/car/ICarImpl.java
ICarImpl实现了ICar.Stub是和应用层通信AIDL的服务端。内部完成了CarService中所有服务的加载和初始化工作。并且应用层实际也是通过此类来拿到相关服务的AIDL代理。
创建相关服务对象
ICarImpl(Context serviceContext, IVehicle vehicle, SystemInterface systemInterface,
CanBusErrorNotifier errorNotifier, String vehicleInterfaceName,
@Nullable CarUserService carUserService,
@Nullable CarWatchdogService carWatchdogService) {
mContext = serviceContext;
mSystemInterface = systemInterface;
mHal = new VehicleHal(serviceContext, vehicle);
......
mCarPropertyService = new CarPropertyService(serviceContext, mHal.getPropertyHal());
......
List<CarServiceBase> allServices = new ArrayList<>();
allServices.add(mCarPropertyService);
mAllServices = allServices.toArray(new CarServiceBase[allServices.size()]);
}
初始化
@MainThread
void init() {
mBootTiming = new TimingsTraceLog(VHAL_TIMING_TAG, Trace.TRACE_TAG_HAL);
traceBegin("VehicleHal.init");
mHal.init();//初始化VehicleHal
traceEnd();
traceBegin("CarService.initAllServices");
for (CarServiceBase service : mAllServices) {
service.init();//各个子service调用init
}
traceEnd();
}
初始化VehicleHal，以及让各个子服务调用init方法
获取子服务
getCarService获取服务代理的接口
public static final String CABIN_SERVICE = "cabin";
public static final String HVAC_SERVICE = "hvac";
public static final String INFO_SERVICE = "info";
public static final String PROPERTY_SERVICE = "property";
public static final String SENSOR_SERVICE = "sensor";
public static final String VENDOR_EXTENSION_SERVICE = "vendor_extension";
@Override
public IBinder getCarService(String serviceName) {
switch (serviceName) {
case Car.CABIN_SERVICE:
case Car.HVAC_SERVICE:
case Car.INFO_SERVICE:
case Car.PROPERTY_SERVICE:
case Car.SENSOR_SERVICE:
case Car.VENDOR_EXTENSION_SERVICE:
return mCarPropertyService;
}
}
以上所有字段的接口都会返回CarPropertyService，这里除了PROPERTY_SERVICE，其它字段已经不推荐使用（ @deprecated）。
CarPropertyService
管理车辆属性的服务，车辆属性通过此服务完成对系统应用层和硬件抽象层的数据通信。其中有一个重要的成员变量PropertyHalService，其具体功能通过PropertyHalService接口调用实现。CarPropertyService其功能主要是维护客户端注册的listener。CarPropertyService来负责车辆属性的管理，使上层应用更易于处理车辆属性。
CarProperty继承了ICarProperty.Stub，作为和系统应用通信的服务端
public class CarPropertyService extends ICarProperty.Stub
ICarProperty代码：packages/services/Car/car-lib/src/android/car/hardware/property/ICarProperty.aidl
package android.car.hardware.property;
import android.car.hardware.CarPropertyConfig;
import android.car.hardware.CarPropertyValue;
import android.car.hardware.property.ICarPropertyEventListener;
/**
* @hide
*/
interface ICarProperty {
void registerListener(int propId, float rate, in ICarPropertyEventListener callback) = 0;
void unregisterListener(int propId, in ICarPropertyEventListener callback) = 1;
List<CarPropertyConfig> getPropertyList() = 2;
CarPropertyValue getProperty(int prop, int zone) = 3;
void setProperty(in CarPropertyValue prop, in ICarPropertyEventListener callback) = 4;
String getReadPermission(int propId) = 5;
String getWritePermission(int propId) = 6;
}
重要属性说明
private final Map<IBinder, Client> mClientMap = new ConcurrentHashMap<>();
private final Map<Integer, CarPropertyConfig<?>> mConfigs = new HashMap<>();
private final PropertyHalService mHal;
private boolean mListenerIsSet = false;
private final Map<Integer, List<Client>> mPropIdClientMap = new ConcurrentHashMap<>();
private final SparseArray<SparseArray<Client>> mSetOperationClientMap = new SparseArray<>();
private final HandlerThread mHandlerThread =
CarServiceUtils.getHandlerThread(getClass().getSimpleName());
private final Handler mHandler = new Handler(mHandlerThread.getLooper());
-
mCientMap存放listener和Client对象的Map对象。Client
维护Service的回调接口的辅助类、每一个新注册的callback都会创建一个Client对象private class Client implements IBinder.DeathRecipient { private final ICarPropertyEventListener mListener; private final IBinder mListenerBinder; private final SparseArray<Float> mRateMap = new SparseArray<Float>(); } -
mConfigs存放系统支持的所有车辆属性 -
mHalPropertyHalService实例，处理和hal交互的逻辑 -
mPropIdClientMap用来存放注册了车辆属性的Client -
mSetOperationClientMap存放进行set操作的车辆属性记录
CarPropertyService::registerListener
注册一个车辆属性的监听。注册时会检测权限ICarImpl.assertPermission(mContext, mHal.getReadPermission(propId)); 并在注册成功后立即进行一次回调mHandler.post(() -> getAndDispatchPropertyInitValue(propertyConfig, finalClient));
client.getListener().onEvent(events);
@Override
public void registerListener(int propId, float rate, ICarPropertyEventListener listener) {
if (DBG) {
Log.d(TAG, "registerListener: propId=0x" + toHexString(propId) + " rate=" + rate);
}
if (listener == null) {
Log.e(TAG, "registerListener: Listener is null.");
throw new IllegalArgumentException("listener cannot be null.");
}
IBinder listenerBinder = listener.asBinder();
CarPropertyConfig propertyConfig;
Client finalClient;
synchronized (mLock) {
propertyConfig = mConfigs.get(propId);
if (propertyConfig == null) {
// Do not attempt to register an invalid propId
Log.e(TAG, "registerListener: propId is not in config list: 0x" + toHexString(
propId));
return;
}
ICarImpl.assertPermission(mContext, mHal.getReadPermission(propId));
// Get or create the client for this listener
Client client = mClientMap.get(listenerBinder);
if (client == null) {
client = new Client(listener);
}
client.addProperty(propId, rate);
// Insert the client into the propId --> clients map
List<Client> clients = mPropIdClientMap.get(propId);
if (clients == null) {
clients = new CopyOnWriteArrayList<Client>();
mPropIdClientMap.put(propId, clients);
}
if (!clients.contains(client)) {
clients.add(client);
}
// Set the HAL listener if necessary
if (!mListenerIsSet) {
mHal.setListener(this);
}
// Set the new rate
if (rate > mHal.getSampleRate(propId)) {
mHal.subscribeProperty(propId, rate);
}
finalClient = client;
}
// propertyConfig and client are NonNull.
mHandler.post(() ->
getAndDispatchPropertyInitValue(propertyConfig, finalClient));
}
private void getAndDispatchPropertyInitValue(CarPropertyConfig config, Client client) {
List<CarPropertyEvent> events = new LinkedList<>();
int propId = config.getPropertyId();
if (config.isGlobalProperty()) {
CarPropertyValue value = mHal.getProperty(propId, 0);
if (value != null) {
CarPropertyEvent event = new CarPropertyEvent(
CarPropertyEvent.PROPERTY_EVENT_PROPERTY_CHANGE, value);
events.add(event);
}
} else {
for (int areaId : config.getAreaIds()) {
CarPropertyValue value = mHal.getProperty(propId, areaId);
if (value != null) {
CarPropertyEvent event = new CarPropertyEvent(
CarPropertyEvent.PROPERTY_EVENT_PROPERTY_CHANGE, value);
events.add(event);
}
}
}
try {
client.getListener().onEvent(events);
} catch (RemoteException ex) {
// If we cannot send a record, its likely the connection snapped. Let the binder
// death handle the situation.
Log.e(TAG, "onEvent calling failed: " + ex);
}
}
CarPropertyService::unregisterListener
取消注册车辆属性监听器
@Override
public void unregisterListener(int propId, ICarPropertyEventListener listener) {
if (DBG) {
Log.d(TAG, "unregisterListener propId=0x" + toHexString(propId));
}
ICarImpl.assertPermission(mContext, mHal.getReadPermission(propId));
if (listener == null) {
Log.e(TAG, "unregisterListener: Listener is null.");
throw new IllegalArgumentException("Listener is null");
}
IBinder listenerBinder = listener.asBinder();
synchronized (mLock) {
unregisterListenerBinderLocked(propId, listenerBinder);
}
}
CarPropertyService::getPropertyList
获取车辆属性列表
@Override
public List<CarPropertyConfig> getPropertyList() {
List<CarPropertyConfig> returnList = new ArrayList<CarPropertyConfig>();
Set<CarPropertyConfig> allConfigs;
synchronized (mLock) {
allConfigs = new HashSet<>(mConfigs.values());
}
for (CarPropertyConfig c : allConfigs) {
if (ICarImpl.hasPermission(mContext, mHal.getReadPermission(c.getPropertyId()))) {
// Only add properties the list if the process has permissions to read it
returnList.add(c);
}
}
if (DBG) {
Log.d(TAG, "getPropertyList returns " + returnList.size() + " configs");
}
return returnList;
}
CarPropertyService::getProperty
获取车辆属性
@Override
public CarPropertyValue getProperty(int prop, int zone) {
synchronized (mLock) {
if (mConfigs.get(prop) == null) {
// Do not attempt to register an invalid propId
Log.e(TAG, "getProperty: propId is not in config list:0x" + toHexString(prop));
return null;
}
}
ICarImpl.assertPermission(mContext, mHal.getReadPermission(prop));
return mHal.getProperty(prop, zone);
}
CarPropertyService::setProperty
设置车辆属性
@Override
public void setProperty(CarPropertyValue prop, ICarPropertyEventListener listener) {
int propId = prop.getPropertyId();
checkPropertyAccessibility(propId);
// need an extra permission for writing display units properties.
if (mHal.isDisplayUnitsProperty(propId)) {
ICarImpl.assertPermission(mContext, Car.PERMISSION_VENDOR_EXTENSION);
}
mHal.setProperty(prop);
IBinder listenerBinder = listener.asBinder();
synchronized (mLock) {
Client client = mClientMap.get(listenerBinder);
if (client == null) {
client = new Client(listener);
}
updateSetOperationRecorder(propId, prop.getAreaId(), client);
}
}
CarPropertyService::onPropertyChange
处理车辆属性回调，将硬件抽象层的车辆属性变化通知给系统应用层。
@Override
public void onPropertyChange(List<CarPropertyEvent> events) {
Map<IBinder, Pair<ICarPropertyEventListener, List<CarPropertyEvent>>> eventsToDispatch =
new HashMap<>();
for (CarPropertyEvent event : events) {
int propId = event.getCarPropertyValue().getPropertyId();
List<Client> clients = mPropIdClientMap.get(propId);
if (clients == null) {
Log.e(TAG, "onPropertyChange: no listener registered for propId=0x"
+ toHexString(propId));
continue;
}
for (Client c : clients) {
IBinder listenerBinder = c.getListenerBinder();
Pair<ICarPropertyEventListener, List<CarPropertyEvent>> p =
eventsToDispatch.get(listenerBinder);
if (p == null) {
// Initialize the linked list for the listener
p = new Pair<>(c.getListener(), new LinkedList<CarPropertyEvent>());
eventsToDispatch.put(listenerBinder, p);
}
p.second.add(event);
}
}
// Parse the dispatch list to send events
for (Pair<ICarPropertyEventListener, List<CarPropertyEvent>> p: eventsToDispatch.values()) {
try {
p.first.onEvent(p.second);
} catch (RemoteException ex) {
// If we cannot send a record, its likely the connection snapped. Let binder
// death handle the situation.
Log.e(TAG, "onEvent calling failed: " + ex);
}
}
}
PropertyHalService
在CarPropertyService中用来处理和硬件抽象层通信的类，主要将系统框架层和硬件抽象层的数据结构进行转换，依赖CarPropertyUtils这个工具类。
重要属性说明
private final LinkedList<CarPropertyEvent> mEventsToDispatch = new LinkedList<>();
@GuardedBy("mLock")
private final Map<Integer, CarPropertyConfig<?>> mMgrPropIdToCarPropConfig = new HashMap<>();
@GuardedBy("mLock")
private final SparseArray<VehiclePropConfig> mHalPropIdToVehiclePropConfig =
new SparseArray<>();
// Only contains propId if the property Id is different in HAL and manager
private static final Map<Integer, Integer> PROPERTY_ID_HAL_TO_MANAGER = Map.of(
VehicleProperty.VEHICLE_SPEED_DISPLAY_UNITS,
VehiclePropertyIds.VEHICLE_SPEED_DISPLAY_UNITS);
// Only contains propId if the property Id is different in HAL and manager
private static final Map<Integer, Integer> PROPERTY_ID_MANAGER_TO_HAL = Map.of(
VehiclePropertyIds.VEHICLE_SPEED_DISPLAY_UNITS,
VehicleProperty.VEHICLE_SPEED_DISPLAY_UNITS);
private static final String TAG = "PropertyHalService";
private final VehicleHal mVehicleHal;
private final PropertyHalServiceIds mPropIds;
@GuardedBy("mLock")
private PropertyHalListener mListener;
@GuardedBy("mLock")
private Set<Integer> mSubscribedHalPropIds;
-
mEventsToDispatch即将上报的数据列表，这个数据会直接发给CarPropertyService上报。这个设计很棒，接收到的数据保存在列表中，可以避免数据丢失。整个列表发给上层处理，PropertyHalService又避免了对数据阻塞。 -
mProps车辆属的配置，在takeSupportedProperties方法完成属性的增加。 -
mVehicleHalVehicleHal的实例 -
mPropIds数据类PropertyHalServiceIds的实例，维护系统车辆属性的权限private final PropertyHalServiceIds mPropIds; public PropertyHalService(VehicleHal vehicleHal) { mPropIds = new PropertyHalServiceIds(); } public String getReadPermission(int propId) { return mPropIds.getReadPermission(propId); } @Nullable public String getWritePermission(int propId) { return mPropIds.getWritePermission(propId); } -
mSubscribedPropIds监听车辆属性的集合，使用集合可以有效的屏蔽重复注册的监听
PropertyHalService::getProperty
获取一个车辆属性，将硬件抽象层数据结构转换成系统框架层数据结构。
public CarPropertyValue getProperty(int mgrPropId, int areaId) {
int halPropId = managerToHalPropId(mgrPropId);
if (!isPropertySupportedInVehicle(halPropId)) {
throw new IllegalArgumentException("Invalid property Id : 0x" + toHexString(mgrPropId));
}
// CarPropertyManager catches and rethrows exception, no need to handle here.
VehiclePropValue value = mVehicleHal.get(halPropId, areaId);
if (isMixedTypeProperty(halPropId)) {
VehiclePropConfig propConfig;
synchronized (mLock) {
propConfig = mHalPropIdToVehiclePropConfig.get(halPropId);
}
boolean containBooleanType = propConfig.configArray.get(1) == 1;
return value == null ? null : toMixedCarPropertyValue(value,
mgrPropId, containBooleanType);
}
return value == null ? null : toCarPropertyValue(value, mgrPropId);
}
isPropertySupportedInVehicle(halPropId)判断这个车辆属性是否支持VehiclePropValue value = mVehicleHal.get(halPropId, areaId)通过VehicleHal获取车辆属性toCarPropertyValue(value, mgrPropId)将硬件抽象层数据结构转换成系统框架层数据结构。
PropertyHalService::setProperty
设置一个车辆属性，将系统框架层数据结构转换成硬件抽象层数据结构。
public void setProperty(CarPropertyValue prop) {
int halPropId = managerToHalPropId(prop.getPropertyId());
if (!isPropertySupportedInVehicle(halPropId)) {
throw new IllegalArgumentException("Invalid property Id : 0x"
+ toHexString(prop.getPropertyId()));
}
VehiclePropValue halProp;
if (isMixedTypeProperty(halPropId)) {
// parse mixed type property value.
VehiclePropConfig propConfig;
synchronized (mLock) {
propConfig = mHalPropIdToVehiclePropConfig.get(prop.getPropertyId());
}
int[] configArray = propConfig.configArray.stream().mapToInt(i->i).toArray();
halProp = toMixedVehiclePropValue(prop, halPropId, configArray);
} else {
halProp = toVehiclePropValue(prop, halPropId);
}
// CarPropertyManager catches and rethrows exception, no need to handle here.
mVehicleHal.set(halProp);
}
int halPropId = managerToHalPropId(prop.getPropertyId())转换成硬件抽象层用的车辆属性IDtoVehiclePropValue(prop, halPropId)将系统框架层数据结构转换称硬件抽象层数据结构。mVehicleHal.set(halProp)通过VehicleHal设置车辆属性
PropertyHalService::onHalEvents
完成VehiclePropValue（硬件抽象层数据结构）到CarPropertyValue（系统框架层数据结构）的转化，并将其封装成CarPropertyEvent数据通知给上层。
@Override
public void onHalEvents(List<VehiclePropValue> values) {
PropertyHalListener listener;
synchronized (mLock) {
listener = mListener;
}
if (listener != null) {
for (VehiclePropValue v : values) {
if (v == null) {
continue;
}
if (!isPropertySupportedInVehicle(v.prop)) {
Log.e(TAG, "Property is not supported: 0x" + toHexString(v.prop));
continue;
}
// Check payload if it is a userdebug build.
if (Build.IS_DEBUGGABLE && !mPropIds.checkPayload(v)) {
Log.e(TAG, "Drop event for property: " + v + " because it is failed "
+ "in payload checking.");
continue;
}
int mgrPropId = halToManagerPropId(v.prop);
CarPropertyValue<?> propVal;
if (isMixedTypeProperty(v.prop)) {
// parse mixed type property value.
VehiclePropConfig propConfig;
synchronized (mLock) {
propConfig = mHalPropIdToVehiclePropConfig.get(v.prop);
}
boolean containBooleanType = propConfig.configArray.get(1) == 1;
propVal = toMixedCarPropertyValue(v, mgrPropId, containBooleanType);
} else {
propVal = toCarPropertyValue(v, mgrPropId);
}
CarPropertyEvent event = new CarPropertyEvent(
CarPropertyEvent.PROPERTY_EVENT_PROPERTY_CHANGE, propVal);
mEventsToDispatch.add(event);
}
listener.onPropertyChange(mEventsToDispatch);
mEventsToDispatch.clear();
}
}
PropertyHalService::getPropertyList
getPropertyList 返回车辆属性的列表，其实也就是自己维护的mProps对象。也是CarPropertyService中维护的mConfigs
public Map<Integer, CarPropertyConfig<?>> getPropertyList() {
if (mDbg) {
Log.d(TAG, "getPropertyList");
}
return mProps;
}
VehicleHal
管理所有的*halservice，这些服务都是通过车辆属性来实现数据通信的，但是其所支持的车辆属性又相对独立，互不影响。现在包括的服务如下
PowerHalServicePropertyHalServiceInputHalServiceVmsHalServiceDiagnosticHalService
VehicleHal继承了IVehicleCallback.Stub，是可以接收硬件抽象层的HIDL回调。
VehicleHal::init
初始化mAllProperties，从HAL层获取车辆属性配置增加到Map中。初始化所有的子服务。
public void init() {
fetchAllPropConfigs();//遍历所有属性，从hal层获取将属性加到mAllProperties对象中
// PropertyHalService will take most properties, so make it big enough.
ArrayList<VehiclePropConfig> configsForService = new ArrayList<>(mAllServices.size());
for (int i = 0; i < mAllServices.size(); i++) {
HalServiceBase service = mAllServices.get(i);
int[] supportedProps = service.getAllSupportedProperties();//获取子服务支持的车辆属性
configsForService.clear();
synchronized (mLock) {
if (supportedProps.length == 0) {
//这里是PropertyHalService
for (Integer propId : mAllProperties.keySet()) {
if (service.isSupportedProperty(propId)) {
VehiclePropConfig config = mAllProperties.get(propId);
mPropertyHandlers.append(propId, service);
configsForService.add(config);
}
}
} else {
//这里是其他
for (int prop : supportedProps) {
VehiclePropConfig config = mAllProperties.get(prop);
if (config == null) {
continue;
}
mPropertyHandlers.append(prop, service);
configsForService.add(config);
}
}
}
service.takeProperties(configsForService);
service.init();
}
}
-
fetchAllPropConfigs遍历所有属性，从硬件层获取将属性加到mAllProperties对象中 -
getAllSupportedProperties获取子服务支持的车辆属性 -
PropertyHalService会执行上面的判断public int[] getAllSupportedProperties() { return CarServiceUtils.EMPTY_INT_ARRAY; } private static final int[] EMPTY_INT_ARRAY = new int[0]; -
当判断改属性支持支持后将属性配置到
mPropertyHandlers和configsForService，mPropertyHandlers记录车辆属性和处理的子服务，configsForService记录车辆属性的VehiclePropConfig -
调用子服务的
takeProperties方法，该方法确认在fw的配置是否支持，配置定义在PropertyHalServiceIds.java中，定义了车辆属性需要的系统权限。
VehicleHal::get
get方法用来获取车辆属性，实际的执行者是HalClient
public VehiclePropValue get(int propertyId, int areaId) {
if (DBG) {
Log.i(CarLog.TAG_HAL, "get, property: 0x" + toHexString(propertyId)
+ ", areaId: 0x" + toHexString(areaId));
}
VehiclePropValue propValue = new VehiclePropValue();
propValue.prop = propertyId;
propValue.areaId = areaId;
return mHalClient.getValue(propValue);
}
VehicleHal::set
set方法用来设置车辆属性，实际的执行者是HalClient
protected void set(VehiclePropValue propValue) {
mHalClient.setValue(propValue);
}
VehicleHal::getAllPropConfigs
getAllPropConfigs方法用来从硬件抽象层获取所有的车辆属性配置
public Collection<VehiclePropConfig> getAllPropConfigs() {
return mAllProperties.values();
}
VehicleHal::onPropertyEvent
onPropertyEvent方法用来监听硬件抽象层传来的车辆属性变化。
@Override
public void onPropertyEvent(ArrayList<VehiclePropValue> propValues) {
synchronized (mLock) {
for (VehiclePropValue v : propValues) {
HalServiceBase service = mPropertyHandlers.get(v.prop);
if(service == null) {
Log.e(CarLog.TAG_HAL, "HalService not found for prop: 0x"
+ toHexString(v.prop));
continue;
}
service.getDispatchList().add(v);
mServicesToDispatch.add(service);
VehiclePropertyEventInfo info = mEventLog.get(v.prop);
if (info == null) {
info = new VehiclePropertyEventInfo(v);
mEventLog.put(v.prop, info);
} else {
info.addNewEvent(v);
}
}
}
for (HalServiceBase s : mServicesToDispatch) {
s.onHalEvents(s.getDispatchList());
s.getDispatchList().clear();
}
mServicesToDispatch.clear();
}
-
onPropertyEvent重写了HIDL接口IVehicleCallback代码路径：automotive\vehicle\2.0\IVehicleCallback.halpackage android.hardware.automotive.vehicle@2.0; interface IVehicleCallback { /** * Event callback happens whenever a variable that the API user has * subscribed to needs to be reported. This may be based purely on * threshold and frequency (a regular subscription, see subscribe call's * arguments) or when the IVehicle#set method was called and the actual * change needs to be reported. * * These callbacks are chunked. * * @param values that has been updated. */ oneway onPropertyEvent(vec<VehiclePropValue> propValues); /** * This method gets called if the client was subscribed to a property using * SubscribeFlags::EVENTS_FROM_ANDROID flag and IVehicle#set(...) method was called. * * These events must be delivered to subscriber immediately without any * batching. * * @param value Value that was set by a client. */ oneway onPropertySet(VehiclePropValue propValue); /** * Set property value is usually asynchronous operation. Thus even if * client received StatusCode::OK from the IVehicle::set(...) this * doesn't guarantee that the value was successfully propagated to the * vehicle network. If such rare event occurs this method must be called. * * @param errorCode - any value from StatusCode enum. * @param property - a property where error has happened. * @param areaId - bitmask that specifies in which areas the problem has * occurred, must be 0 for global properties */ oneway onPropertySetError(StatusCode errorCode, int32_t propId, int32_t areaId); }; -
从硬件抽象层获取到的是一个
ArrayList，这里会循环遍历列表中每一个车辆属性。 -
HalServiceBase service = mPropertyHandlers.get(v.prop);这个是获取当前车辆属性需要通知的子HalService或者说是获取管理这个车辆属性的服务。 -
service.getDispatchList().add(v)将这个车辆属性添加到管理这个服务的分派列表中。 -
mServicesToDispatch.add(service);将此子服务添加到服务分发列表中。 -
s.onHalEvents(s.getDispatchList());是将前面识别到的车辆属性，让其对应的服务执行分发操作。普通车辆属性的执行者是PropertyHalService。
HalClient
相当于VehicleHal的代理类，VehicleHal中定义了和硬件抽象层交互的接口，但是具体实现实际都是通过HalClient来进行调用的。HalClient中持有硬件抽象层VehicleService的句柄。
HalClient::getAllPropConfigs
获取全部的车辆属性配置
ArrayList<VehiclePropConfig> getAllPropConfigs() throws RemoteException {
return mVehicle.getAllPropConfigs();
}
HalClient::subscribe
订阅一个车辆属性变化
public void subscribe(SubscribeOptions... options) throws RemoteException {
mVehicle.subscribe(mInternalCallback, new ArrayList<>(Arrays.asList(options)));
}
HalClient::unsubscribe
取消一个车辆属性订阅
public void unsubscribe(int prop) throws RemoteException {
mVehicle.unsubscribe(mInternalCallback, prop);
}
HalClient::setValue
设置一个车辆属性
public void setValue(VehiclePropValue propValue) {
int status = invokeRetriable(() -> {
try {
return mVehicle.set(propValue);
} catch (RemoteException e) {
Log.e(TAG, getValueErrorMessage("set", propValue), e);
return StatusCode.TRY_AGAIN;
}
}, mWaitCapMs, mSleepMs);
if (StatusCode.INVALID_ARG == status) {
throw new IllegalArgumentException(getValueErrorMessage("set", propValue));
}
if (StatusCode.OK != status) {
Log.e(TAG, getPropertyErrorMessage("set", propValue, status));
throw new ServiceSpecificException(status,
"Failed to set property: 0x" + Integer.toHexString(propValue.prop)
+ " in areaId: 0x" + Integer.toHexString(propValue.areaId));
}
}
HalClient::getValue
获取一个车辆属性
VehiclePropValue getValue(VehiclePropValue requestedPropValue) {
final ObjectWrapper<VehiclePropValue> valueWrapper = new ObjectWrapper<>();
int status = invokeRetriable(() -> {
ValueResult res = internalGet(requestedPropValue);
valueWrapper.object = res.propValue;
return res.status;
}, mWaitCapMs, mSleepMs);
if (StatusCode.INVALID_ARG == status) {
throw new IllegalArgumentException(getValueErrorMessage("get", requestedPropValue));
}
if (StatusCode.OK != status || valueWrapper.object == null) {
// If valueWrapper.object is null and status is StatusCode.Ok, change the status to be
// NOT_AVAILABLE.
if (StatusCode.OK == status) {
status = StatusCode.NOT_AVAILABLE;
}
Log.e(TAG, getPropertyErrorMessage("get", requestedPropValue, status));
throw new ServiceSpecificException(status,
"Failed to get property: 0x" + Integer.toHexString(requestedPropValue.prop)
+ " in areaId: 0x" + Integer.toHexString(requestedPropValue.areaId));
}
return valueWrapper.object;
}
private ValueResult internalGet(VehiclePropValue requestedPropValue) {
final ValueResult result = new ValueResult();
try {
mVehicle.get(requestedPropValue,
(status, propValue) -> {
result.status = status;
result.propValue = propValue;
});
} catch (RemoteException e) {
Log.e(TAG, getValueErrorMessage("get", requestedPropValue), e);
result.status = StatusCode.TRY_AGAIN;
}
return result;
}
CarPropertyConfig
车辆属性的属性配置，在FW层使用的，由硬件抽象层的VehiclePropConfig转化而来。定义了车辆属性的基本信息。包括读写性质、类型、变化模式等等。
private final int mAccess;
private final int mAreaType;
private final int mChangeMode;
private final ArrayList<Integer> mConfigArray;
private final String mConfigString;
private final float mMaxSampleRate;
private final float mMinSampleRate;
private final int mPropertyId;
private final SparseArray<AreaConfig<T>> mSupportedAreas;
private final Class<T> mType;
CarPropertyUtils
一个工具类，将硬件抽象层数据结构和系统框架层数据结构相互进行转换。
-
toCarPropertyValue
转换VehiclePropValue变成CarPropertyValue。（HAL->FW）static CarPropertyValue<?> toCarPropertyValue( VehiclePropValue halValue, int propertyId) -
toVehiclePropValue
转换CarPropertyValue变成VehiclePropValue。（HW->HAL）static VehiclePropValue toVehiclePropValue(CarPropertyValue carProp, int halPropId) -
toCarPropertyConfig
转换VehiclePropConfig变成CarPropertyConfig。（HAL->FW）static CarPropertyConfig<?> toCarPropertyConfig(VehiclePropConfig p, int propertyId)
转化关系
| 方法 | 转化关系 |
|---|---|
| toCarPropertyValue | VehiclePropValue ->CarPropertyValue(fw) |
| toVehiclePropValue | CarPropertyValue ->VehiclePropValue(hal) |
| toCarPropertyConfig | VehiclePropConfig ->CarPropertyConfig(fw) |
CarPropertyConfig是某一个车辆属性的信息。相当于Map中的KEY。
CarPropertyValue 是某一个车辆属性返回的值。相当于Map中的Value。
VehiclePropConfig和VehiclePropValue的定义实际上是在types.hal中。
CarPropertyValue变量的对应关系
| CarPropertyValue | VehiclePropValue |
|---|---|
mPropertyId int |
prop int32_t |
mAreaIdint |
areaIdint32_t |
mStatusint |
statusint32_t |
mTimestamp long |
timestamp int64_t |
mValue T |
value RawValue |
系统框架层的CarPropertyValue返回值是一个泛型，可以根据属性实际的定义来决定对应的类型。硬件抽象层定义是一个数据结构，RawValue里定义了常规类型的数组和字符串。
struct RawValue {
vec<int32_t> int32Values;
vec<float> floatValues;
vec<int64_t> int64Values;
vec<uint8_t> bytes;
string stringValue;
};
如果是数据类型不是数组，会占用数组的第0位返回，布尔型会用int32Values.get(0) == 1
CarPropertyConfig变量的对应关系
| CarPropertyConfig | VehiclePropConfig |
|---|---|
mAccess int |
access VehiclePropertyAccess |
mAreaType int |
|
mChangeMode int |
changeMode VehiclePropertyChangeMode |
mConfigArray ArrayList<Integer> |
configArray vec<int32_t> |
mConfigString String |
configString string |
mMaxSampleRate float |
maxSampleRate float |
mMinSampleRate float |
minSampleRate float |
mPropertyId int |
prop int32_t |
mSupportedAreas SparseArray<AreaConfig<T>> mSupportedAreas |
areaConfigs vec<VehicleAreaConfig> |
mType Class<T> |
mType是根据车辆属性的定义计算出来的，Class<?> clazz = getJavaClass(p.prop & VehiclePropertyType.MASK)
PropertyHalServiceIds
定义了PropertyHalService支持的车辆属性。此类将读写权限绑定到属性ID。提供获取车辆属性权限定义的接口
代码路径：packages/services/Car/service/src/com/android/car/hal/PropertyHalServiceIds.java
public class PropertyHalServiceIds {
// Index (key is propertyId, and the value is readPermission, writePermission
private final SparseArray<Pair<String, String>> mProps;
public PropertyHalServiceIds() {
mProps = new SparseArray<>();
// Add propertyId and read/write permissions
// 在构造函数中绑定权限
mProps.put(VehicleProperty.DOOR_POS, new Pair<>(
Car.PERMISSION_CONTROL_CAR_DOORS,
Car.PERMISSION_CONTROL_CAR_DOORS));
//......
}
}
-
getReadPermission()获取读取权限，返回值为字符串public String getReadPermission(int propId) { Pair<String, String> p = mProps.get(propId); if (p != null) { // Property ID exists. Return read permission. if (p.first == null) { Log.e(TAG, "propId is not available for reading : 0x" + toHexString(propId)); } return p.first; } else if (isVendorProperty(propId)) { // if property is vendor property and do not have specific permission. return Car.PERMISSION_VENDOR_EXTENSION; } else { return null; } } -
getWritePermission()获取写入权限，返回值为字符串public String getWritePermission(int propId) { Pair<String, String> p = mProps.get(propId); if (p != null) { // Property ID exists. Return write permission. if (p.second == null) { Log.e(TAG, "propId is not writable : 0x" + toHexString(propId)); } return p.second; } else if (isVendorProperty(propId)) { // if property is vendor property and do not have specific permission. return Car.PERMISSION_VENDOR_EXTENSION; } else { return null; } } -
isSupportedProperty()检查车辆属性是否在PropertyHalService的已知列表中public boolean isSupportedProperty(int propId) { // Property is in the list of supported properties return mProps.get(propId) != null || isVendorProperty(propId); }private static boolean isVendorProperty(int propId) { return (propId & VehiclePropertyGroup.MASK) == VehiclePropertyGroup.VENDOR; }
总结
| 类 | 说明 |
|---|---|
| CarService | Car的主服务 |
| ICarImpl | 具体Car的实现类 |
| VehicleHal | 实现IVehicleCallback接口的类，并维护各个子服务 |
| PropertyHalService | 处理HAL层获取到的数据并将其转化成FW层使用的类型 |
| HalClient | 持有IVehile接口，代理实际操作 |
| PropertyHalServiceIds | 定义支持的属性以及权限 |
| CarPropertyUtils | 工具类，转化FW层和HAL层数据 |
| CarPropertyConfig | 车辆属性配置信息 |
| CarPropertyService | 车辆属性控制的子服务 |
| Client | 车辆车辆属性订阅通知的类 |
CarService作为主服务，通过ICarImpl类实现对子服务CarPropertyService的创建以及对VehicleHal的初始化。VehicleHal中完成对子服务们的初始化，并通过传入的IVehicle对象使得PropertyHalService获取系统支持的车辆属性，完成初始化操作。在PropertyHalService中创建HalClient对象完成对IVehicle接口的实际调用，并将从HAL层获取的数据类型转化成FW层使用数据类型。CarPropertyService持有PropertyHalService的引用，完成上下层的数据交互操作。对于APPLICATION注册的Listener，CarPropertyService使用Client对象进行维护，当订阅的数据发生变化进行通知，当首次注册时，会主动获取值并进行一次通知操作。
关联关系：CarPropertyManager --> ICarProperty --> CarPropertyService --> PropertyHalService --> VehicleHal
|
| --------------------- | ----------------------------------------------- |
| CarService | Car的主服务 |
| ICarImpl | 具体Car的实现类 |
| VehicleHal | 实现IVehicleCallback接口的类，并维护各个子服务 |
| PropertyHalService | 处理HAL层获取到的数据并将其转化成FW层使用的类型 |
| HalClient | 持有IVehile接口，代理实际操作 |
| PropertyHalServiceIds | 定义支持的属性以及权限 |
| CarPropertyUtils | 工具类，转化FW层和HAL层数据 |
| CarPropertyConfig | 车辆属性配置信息 |
| CarPropertyService | 车辆属性控制的子服务 |
| Client | 车辆车辆属性订阅通知的类 |
CarService作为主服务，通过ICarImpl类实现对子服务CarPropertyService的创建以及对VehicleHal的初始化。VehicleHal中完成对子服务们的初始化，并通过传入的IVehicle对象使得PropertyHalService获取系统支持的车辆属性，完成初始化操作。在PropertyHalService中创建HalClient对象完成对IVehicle接口的实际调用，并将从HAL层获取的数据类型转化成FW层使用数据类型。CarPropertyService持有PropertyHalService的引用，完成上下层的数据交互操作。对于APPLICATION注册的Listener，CarPropertyService使用Client对象进行维护，当订阅的数据发生变化进行通知，当首次注册时，会主动获取值并进行一次通知操作。
关联关系：CarPropertyManager --> ICarProperty --> CarPropertyService --> PropertyHalService --> VehicleHal