Android车载——VehicleHal运行流程（Android 11）

1 概述

本篇重要讲解VehicleHal的重要运行流程，包括设置属性、获取属性、订阅属性、取消订阅、持续上报属性订阅等。
2 获取属性流程

2.1 获取属性流程源码分析

作为服务注册到hwServiceManager中的类是VehicleHalManager，所以，CarService对服务端的调用的hidl接口都是调用到了VehicleHalManager中。

1. get(VehiclePropValue requestedPropValue)
2.           generates (StatusCode status, VehiclePropValue propValue);

复制代码

IVehicle这个hidl接口中的界说如上

1. Return<void> VehicleHalManager::get(const VehiclePropValue& requestedPropValue, get_cb _hidl_cb) {
2.     const auto* config = getPropConfigOrNull(requestedPropValue.prop);
3.     if (config == nullptr) {
4.         ALOGE("Failed to get value: config not found, property: 0x%x",
5.               requestedPropValue.prop);
6.         _hidl_cb(StatusCode::INVALID_ARG, kEmptyValue);
7.         return Void();
8.     }
10.     if (!checkReadPermission(*config)) {
11.         _hidl_cb(StatusCode::ACCESS_DENIED, kEmptyValue);
12.         return Void();
13.     }
15.     StatusCode status;
16.     auto value = mHal->get(requestedPropValue, &status);
17.     _hidl_cb(status, value.get() ? *value : kEmptyValue);
20.     return Void();
21. }

复制代码

调用之后会调用到VehicleHalManager中的get函数

1. const VehiclePropConfig* VehicleHalManager::getPropConfigOrNull(
2.         int32_t prop) const {
3.     return mConfigIndex->hasConfig(prop)
4.            ? &mConfigIndex->getConfig(prop) : nullptr;
5. }

复制代码

起首，会从属性设置列表中是否存在这个属性，这个是初始化的时候缓存的，缓存的是所有的属性设置。
如果获取的属性不在属性设置列表中，则不能够获取，如果存在，会判断访问权限，访问权限校验通过之后，会调用mHal的get函数。

1. VehicleHal::VehiclePropValuePtr EmulatedVehicleHal::get(
2.         const VehiclePropValue& requestedPropValue, StatusCode* outStatus) {
3.     auto propId = requestedPropValue.prop;
4.     ALOGV("get(%d)", propId);
6.     auto& pool = *getValuePool();
7.     VehiclePropValuePtr v = nullptr;
9.     switch (propId) {
10.         case OBD2_FREEZE_FRAME:
11.             v = pool.obtainComplex();
12.             *outStatus = fillObd2FreezeFrame(requestedPropValue, v.get());
13.             break;
14.         case OBD2_FREEZE_FRAME_INFO:
15.             v = pool.obtainComplex();
16.             *outStatus = fillObd2DtcInfo(v.get());
17.             break;
18.         default:
19.             if (mEmulatedUserHal != nullptr && mEmulatedUserHal->isSupported(propId)) {
20.                 ALOGI("get(): getting value for prop %d from User HAL", propId);
21.                 const auto& ret = mEmulatedUserHal->onGetProperty(requestedPropValue);
22.                 if (!ret.ok()) {
23.                     ALOGE("get(): User HAL returned error: %s", ret.error().message().c_str());
24.                     *outStatus = StatusCode(ret.error().code());
25.                 } else {
26.                     auto value = ret.value().get();
27.                     if (value != nullptr) {
28.                         ALOGI("get(): User HAL returned value: %s", toString(*value).c_str());
29.                         v = getValuePool()->obtain(*value);
30.                         *outStatus = StatusCode::OK;
31.                     } else {
32.                         ALOGE("get(): User HAL returned null value");
33.                         *outStatus = StatusCode::INTERNAL_ERROR;
34.                     }
35.                 }
36.                 break;
37.             }
39.             auto internalPropValue = mPropStore->readValueOrNull(requestedPropValue);
40.             if (internalPropValue != nullptr) {
41.                 v = getValuePool()->obtain(*internalPropValue);
42.             }
44.             *outStatus = v != nullptr ? StatusCode::OK : StatusCode::INVALID_ARG;
45.             break;
46.     }
47.     if (v.get()) {
48.         v->timestamp = elapsedRealtimeNano();
49.     }
50.     return v;
51. }

复制代码

起首，会对userhal的一些判断操作，这个EmulatedUserHal是跟用户身份相关的hal界说，用于处置惩罚用户切换相关事件。如果是用户hal相关的prop获取，则获取完成之后就直接跳出。如果不是，则走普通的property获取路径，从VehiclePropertyStore中读取。

1. using PropertyMap = std::map<RecordId, VehiclePropValue>;
2. PropertyMap mPropertyValues;
4. std::unique_ptr<VehiclePropValue> VehiclePropertyStore::readValueOrNull(
5.         int32_t prop, int32_t area, int64_t token) const {
6.     RecordId recId = {prop, isGlobalProp(prop) ? 0 : area, token };
7.     MuxGuard g(mLock);
8.     const VehiclePropValue* internalValue = getValueOrNullLocked(recId);
9.     return internalValue ? std::make_unique<VehiclePropValue>(*internalValue) : nullptr;
10. }
12. const VehiclePropValue* VehiclePropertyStore::getValueOrNullLocked(
13.         const VehiclePropertyStore::RecordId& recId) const  {
14.     auto it = mPropertyValues.find(recId);
15.     return it == mPropertyValues.end() ? nullptr : &it->second;
16. }

复制代码

从mPropertyValues这个map中去获取对应propId的property。mPropertyValues内里的值是在哪添补的呢？

1. bool VehiclePropertyStore::writeValue(const VehiclePropValue& propValue,
2.                                         bool updateStatus) {
3.     MuxGuard g(mLock);
4.     if (!mConfigs.count(propValue.prop)) return false;
6.     RecordId recId = getRecordIdLocked(propValue);
7.     VehiclePropValue* valueToUpdate = const_cast<VehiclePropValue*>(getValueOrNullLocked(recId));
8.     if (valueToUpdate == nullptr) {
9.         mPropertyValues.insert({ recId, propValue });
10.         return true;
11.     }
13.     // propValue is outdated and drops it.
14.     if (valueToUpdate->timestamp > propValue.timestamp) {
15.         return false;
16.     }
17.     // update the propertyValue.
18.     // The timestamp in propertyStore should only be updated by the server side. It indicates
19.     // the time when the event is generated by the server.
20.     valueToUpdate->timestamp = propValue.timestamp;
21.     valueToUpdate->value = propValue.value;
22.     if (updateStatus) {
23.         valueToUpdate->status = propValue.status;
24.     }
25.     return true;
26. }

复制代码

是在这个函数中，这个函数是在VHAL初始化的时候调用的，初始化的时候，会遍历一个界说了所有支持属性的列表，并调用writeValue函数将属性设置和属性值缓存到VehiclePropertyStore中。
以上就是CarService从VHAL获取属性的流程，总结来说就是：从VHAL的缓存map中获取属性。
2.2 获取属性流程图

plantuml

1. @startuml
3. participant CarService
4. box
5. participant VehicleHalManager
6. participant EmulatedVehicleHal
7. participant VehiclePropertyStore
8. endbox
10. CarService -> VehicleHalManager: get(const VehiclePropValue& \n\trequestedPropValue, get_cb _hidl_cb)
11. VehicleHalManager -> EmulatedVehicleHal: get(const VehiclePropValue& \n\trequestedPropValue, get_cb _hidl_cb)
12. EmulatedVehicleHal -> VehiclePropertyStore: readValueOrNull(int32_t prop, \n\tint32_t area, int64_t token)
13. VehiclePropertyStore -> EmulatedVehicleHal: propValue
14. EmulatedVehicleHal -> VehicleHalManager: propValue
15. VehicleHalManager -> CarService: _hidl_cb(propValue)
17. @enduml

复制代码

3 设置属性流程

3.1 设置属性流程源码分析

hidl调用后照旧从VehicleHalManager开始的

1. Return<StatusCode> VehicleHalManager::set(const VehiclePropValue &value) {
2.     auto prop = value.prop;
3.     const auto* config = getPropConfigOrNull(prop);
4.     if (config == nullptr) {
5.         ALOGE("Failed to set value: config not found, property: 0x%x", prop);
6.         return StatusCode::INVALID_ARG;
7.     }
9.     if (!checkWritePermission(*config)) {
10.         return StatusCode::ACCESS_DENIED;
11.     }
13.     handlePropertySetEvent(value);
15.     auto status = mHal->set(value);
17.     return Return<StatusCode>(status);
18. }

复制代码

起首判断缓存中是否有该属性的属性设置，有才支持后续的set操作
handlePropertySetEvent是对带有EVENTS_FROM_ANDROID这个订阅标签属性的处置惩罚，这种属性的设置必要直接上报给上层。
然后是调用EmulatedVehicleHal的set函数

1. StatusCode EmulatedVehicleHal::set(const VehiclePropValue& propValue) {
2.     constexpr bool updateStatus = false;
4.         //这里是模拟车辆属性
5.     if (propValue.prop == kGenerateFakeDataControllingProperty) {
6.         // Send the generator controlling request to the server.
7.         // 'updateStatus' flag is only for the value sent by setProperty (propValue in this case)
8.         // instead of the generated values triggered by it. 'propValue' works as a control signal
9.         // here, since we never send the control signal back, the value of 'updateStatus' flag
10.         // does not matter here.
11.         auto status = mVehicleClient->setProperty(propValue, updateStatus);
12.         return status;
13.     //处理空调相关的属性
14.     } else if (mHvacPowerProps.count(propValue.prop)) {
15.         auto hvacPowerOn = mPropStore->readValueOrNull(
16.             toInt(VehicleProperty::HVAC_POWER_ON),
17.             (VehicleAreaSeat::ROW_1_LEFT | VehicleAreaSeat::ROW_1_RIGHT |
18.              VehicleAreaSeat::ROW_2_LEFT | VehicleAreaSeat::ROW_2_CENTER |
19.              VehicleAreaSeat::ROW_2_RIGHT));
21.         if (hvacPowerOn && hvacPowerOn->value.int32Values.size() == 1
22.                 && hvacPowerOn->value.int32Values[0] == 0) {
23.             return StatusCode::NOT_AVAILABLE;
24.         }
25.     } else {
26.         // Handle property specific code
27.         switch (propValue.prop) {
28.             case OBD2_FREEZE_FRAME_CLEAR:
29.                 return clearObd2FreezeFrames(propValue);
30.             case VEHICLE_MAP_SERVICE:
31.                 // Placeholder for future implementation of VMS property in the default hal. For
32.                 // now, just returns OK; otherwise, hal clients crash with property not supported.
33.                 return StatusCode::OK;
34.         }
35.     }
37.     if (propValue.status != VehiclePropertyStatus::AVAILABLE) {
38.         // Android side cannot set property status - this value is the
39.         // purview of the HAL implementation to reflect the state of
40.         // its underlying hardware
41.         return StatusCode::INVALID_ARG;
42.     }
43.     //读取当前值
44.     auto currentPropValue = mPropStore->readValueOrNull(propValue);
46.     if (currentPropValue == nullptr) {
47.         return StatusCode::INVALID_ARG;
48.     }
49.     if (currentPropValue->status != VehiclePropertyStatus::AVAILABLE) {
50.         // do not allow Android side to set() a disabled/error property
51.         return StatusCode::NOT_AVAILABLE;
52.     }
54.     /**
55.      * After checking all conditions, such as the property is available, a real vhal will
56.      * sent the events to Car ECU to take actions.
57.      */
59.     // Send the value to the vehicle server, the server will talk to the (real or emulated) car
60.     //设置属性到VehicleClient，通过这个设置到模拟车辆或者实际车辆
61.     auto setValueStatus = mVehicleClient->setProperty(propValue, updateStatus);
62.     if (setValueStatus != StatusCode::OK) {
63.         return setValueStatus;
64.     }
66.     return StatusCode::OK;
67. }

复制代码

其中mVehicleClient是初始化时传入的EmulatedVehicleConnector对象，所以调用的是EmulatedVehicleConnector的setProperty函数。

1. StatusCode setProperty(const VehiclePropValue& value, bool updateStatus) override {
2.     return this->onSetProperty(value, updateStatus);
3. }

复制代码

setProperty函数在EmulatedVehicleConnector的父类IPassThroughConnector中，然后调用onSetProperty函数，这个函数在EmulatedVehicleConnector类中。

1. StatusCode EmulatedVehicleConnector::onSetProperty(const VehiclePropValue& value,
2.                                                    bool updateStatus) {
3.     if (mEmulatedUserHal.isSupported(value.prop)) {
4.         LOG(INFO) << "onSetProperty(): property " << value.prop << " will be handled by UserHal";
6.         const auto& ret = mEmulatedUserHal.onSetProperty(value);
7.         if (!ret.ok()) {
8.             LOG(ERROR) << "onSetProperty(): HAL returned error: " << ret.error().message();
9.             return StatusCode(ret.error().code());
10.         }
11.         auto updatedValue = ret.value().get();
12.         if (updatedValue != nullptr) {
13.             LOG(INFO) << "onSetProperty(): updating property returned by HAL: "
14.                       << toString(*updatedValue);
15.             onPropertyValueFromCar(*updatedValue, updateStatus);
16.         }
17.         return StatusCode::OK;
18.     }
19.     return this->VehicleHalServer::onSetProperty(value, updateStatus);
20. }

复制代码

起首处置惩罚UserHal相关的属性操作。然后调用VehicleHalServer中的onSetProperty函数。

1. StatusCode VehicleHalServer::onSetProperty(const VehiclePropValue& value, bool updateStatus) {
2.     LOG(DEBUG) << "onSetProperty(" << value.prop << ")";
4.     // Some properties need to be treated non-trivially
5.     switch (value.prop) {
6.         case kGenerateFakeDataControllingProperty:
7.             return handleGenerateFakeDataRequest(value);
9.         // set the value from vehicle side, used in end to end test.
10.         case kSetIntPropertyFromVehicleForTest: {
11.             auto updatedPropValue = createVehiclePropValue(VehiclePropertyType::INT32, 1);
12.             updatedPropValue->prop = value.value.int32Values[0];
13.             updatedPropValue->value.int32Values[0] = value.value.int32Values[1];
14.             updatedPropValue->timestamp = value.value.int64Values[0];
15.             updatedPropValue->areaId = value.areaId;
16.             onPropertyValueFromCar(*updatedPropValue, updateStatus);
17.             return StatusCode::OK;
18.         }
19.         case kSetFloatPropertyFromVehicleForTest: {
20.             auto updatedPropValue = createVehiclePropValue(VehiclePropertyType::FLOAT, 1);
21.             updatedPropValue->prop = value.value.int32Values[0];
22.             updatedPropValue->value.floatValues[0] = value.value.floatValues[0];
23.             updatedPropValue->timestamp = value.value.int64Values[0];
24.             updatedPropValue->areaId = value.areaId;
25.             onPropertyValueFromCar(*updatedPropValue, updateStatus);
26.             return StatusCode::OK;
27.         }
28.         case kSetBooleanPropertyFromVehicleForTest: {
29.             auto updatedPropValue = createVehiclePropValue(VehiclePropertyType::BOOLEAN, 1);
30.             updatedPropValue->prop = value.value.int32Values[1];
31.             updatedPropValue->value.int32Values[0] = value.value.int32Values[0];
32.             updatedPropValue->timestamp = value.value.int64Values[0];
33.             updatedPropValue->areaId = value.areaId;
34.             onPropertyValueFromCar(*updatedPropValue, updateStatus);
35.             return StatusCode::OK;
36.         }
38.         case AP_POWER_STATE_REPORT:
39.             switch (value.value.int32Values[0]) {
40.                 case toInt(VehicleApPowerStateReport::DEEP_SLEEP_EXIT):
41.                 case toInt(VehicleApPowerStateReport::SHUTDOWN_CANCELLED):
42.                 case toInt(VehicleApPowerStateReport::WAIT_FOR_VHAL):
43.                     // CPMS is in WAIT_FOR_VHAL state, simply move to ON
44.                     // Send back to HAL
45.                     // ALWAYS update status for generated property value
46.                     onPropertyValueFromCar(*createApPowerStateReq(VehicleApPowerStateReq::ON, 0),
47.                                            true /* updateStatus */);
48.                     break;
49.                 case toInt(VehicleApPowerStateReport::DEEP_SLEEP_ENTRY):
50.                 case toInt(VehicleApPowerStateReport::SHUTDOWN_START):
51.                     // CPMS is in WAIT_FOR_FINISH state, send the FINISHED command
52.                     // Send back to HAL
53.                     // ALWAYS update status for generated property value
54.                     onPropertyValueFromCar(
55.                             *createApPowerStateReq(VehicleApPowerStateReq::FINISHED, 0),
56.                             true /* updateStatus */);
57.                     break;
58.                 case toInt(VehicleApPowerStateReport::ON):
59.                 case toInt(VehicleApPowerStateReport::SHUTDOWN_POSTPONE):
60.                 case toInt(VehicleApPowerStateReport::SHUTDOWN_PREPARE):
61.                     // Do nothing
62.                     break;
63.                 default:
64.                     // Unknown state
65.                     break;
66.             }
67.             break;
68.         default:
69.             break;
70.     }
72.     // In the real vhal, the value will be sent to Car ECU.
73.     // We just pretend it is done here and send back to HAL
74.     auto updatedPropValue = getValuePool()->obtain(value);
75.     updatedPropValue->timestamp = elapsedRealtimeNano();
77.     onPropertyValueFromCar(*updatedPropValue, updateStatus);
78.     return StatusCode::OK;
79. }

复制代码

上面是模拟属性设置流程，这里就相当于模拟属性设置完成了。更新属性的值和时间戳之后，调用onPropertyValueFromCar模拟属性设置成功的上报操作
3.2 设置属性流程图

plantuml

1. @startuml
3. participant CarService
4. box
5. participant VehicleHalManager
6. participant SubscriptionManager
7. participant EmulatedVehicleHal
8. participant IPassThroughConnector
9. participant EmulatedVehicleConnector
10. participant VehicleHalServer
11. endbox
13. CarService -> VehicleHalManager: set(const VehiclePropValue& value)
14. VehicleHalManager -> VehicleHalManager: handlePropertySetEvent(const VehiclePropValue& value)
15. VehicleHalManager -> SubscriptionManager: getSubscribedClients(int32_t propId, SubscribeFlags flags)
16. SubscriptionManager -> VehicleHalManager: value
17. alt flags == SubscribeFlags::EVENTS_FROM_ANDROID
18.     VehicleHalManager -> CarService: onPropertySet(value)
19. end
20. VehicleHalManager -> EmulatedVehicleHal: set(const VehiclePropValue& value)
21. EmulatedVehicleHal -> IPassThroughConnector: setProperty(const VehiclePropValue& \n\tvalue, bool updateStatus)
22. IPassThroughConnector -> EmulatedVehicleConnector: onSetProperty(const VehiclePropValue& \n\tvalue, bool updateStatus)
23. EmulatedVehicleConnector -> VehicleHalServer: onSetProperty(const VehiclePropValue& value, bool updateStatus)
25. @enduml

复制代码

流程图：

这里由于没有实际车辆，没有往下设置，OEM厂商必要设置到ECU中。至于设置之后，VHAL缓存的改变则是由设置成功的通知上报之后才会写入缓存的。
4 订阅属性流程

4.1 普通订阅属性流程源码分析

订阅入口也是在VehicleHalManager中

1. Return<StatusCode> VehicleHalManager::subscribe(const sp<IVehicleCallback> &callback,
2.                                                 const hidl_vec<SubscribeOptions> &options) {
3.     hidl_vec<SubscribeOptions> verifiedOptions(options);
4.     for (size_t i = 0; i < verifiedOptions.size(); i++) {
5.         SubscribeOptions& ops = verifiedOptions[i];
6.         auto prop = ops.propId;
8.         const auto* config = getPropConfigOrNull(prop);
9.         if (config == nullptr) {
10.             ALOGE("Failed to subscribe: config not found, property: 0x%x",
11.                   prop);
12.             return StatusCode::INVALID_ARG;
13.         }
15.         if (ops.flags == SubscribeFlags::UNDEFINED) {
16.             ALOGE("Failed to subscribe: undefined flag in options provided");
17.             return StatusCode::INVALID_ARG;
18.         }
20.         if (!isSubscribable(*config, ops.flags)) {
21.             ALOGE("Failed to subscribe: property 0x%x is not subscribable",
22.                   prop);
23.             return StatusCode::INVALID_ARG;
24.         }
26.         ops.sampleRate = checkSampleRate(*config, ops.sampleRate);
27.     }
29.     std::list<SubscribeOptions> updatedOptions;
30.     auto res = mSubscriptionManager.addOrUpdateSubscription(getClientId(callback),
31.                                                             callback, verifiedOptions,
32.                                                             &updatedOptions);
33.     if (StatusCode::OK != res) {
34.         ALOGW("%s failed to subscribe, error code: %d", __func__, res);
35.         return res;
36.     }
38.     for (auto opt : updatedOptions) {
39.         mHal->subscribe(opt.propId, opt.sampleRate);
40.     }
42.     return StatusCode::OK;
43. }

复制代码

起首判断属性设置是否存在，存在才支持订阅
然后判断是否可以订阅

1. bool VehicleHalManager::isSubscribable(const VehiclePropConfig& config,
2.                                        SubscribeFlags flags) {
3.     bool isReadable = config.access & VehiclePropertyAccess::READ;
5.     if (!isReadable && (SubscribeFlags::EVENTS_FROM_CAR & flags)) {
6.         ALOGW("Cannot subscribe, property 0x%x is not readable", config.prop);
7.         return false;
8.     }
9.     if (config.changeMode == VehiclePropertyChangeMode::STATIC) {
10.         ALOGW("Cannot subscribe, property 0x%x is static", config.prop);
11.         return false;
12.     }
13.     return true;
14. }

复制代码

判断访问权限，判断flag，如果flag是从car来的，则返回false。然后是判断属性的changeMode，如果changeMode是STATIC，表现属性不变，则不支持订阅。
然后添加订阅addOrUpdateSubscription，添加之前起首创建clientId

1. using ClientId = uint64_t;
2. ClientId VehicleHalManager::getClientId(const sp<IVehicleCallback>& callback) {
3.     //TODO(b/32172906): rework this to get some kind of unique id for callback interface when this
4.     // feature is ready in HIDL.
6.     if (callback->isRemote()) {
7.         BpHwVehicleCallback* hwCallback = static_cast<BpHwVehicleCallback*>(callback.get());
8.         return static_cast<ClientId>(reinterpret_cast<intptr_t>(hwCallback->onAsBinder()));
9.     } else {
10.         return static_cast<ClientId>(reinterpret_cast<intptr_t>(callback.get()));
11.     }
12. }

复制代码

根据传入的回调函数的额指针来强转成ClientId这种int范例，作为客户端的唯一标识。

1. StatusCode SubscriptionManager::addOrUpdateSubscription(
2.         ClientId clientId,
3.         const sp<IVehicleCallback> &callback,
4.         const hidl_vec<SubscribeOptions> &optionList,
5.         std::list<SubscribeOptions>* outUpdatedSubscriptions) {
6.     outUpdatedSubscriptions->clear();
8.     MuxGuard g(mLock);
10.     ALOGI("SubscriptionManager::addOrUpdateSubscription, callback: %p", callback.get());
12.     const sp<HalClient>& client = getOrCreateHalClientLocked(clientId, callback);
13.     if (client.get() == nullptr) {
14.         return StatusCode::INTERNAL_ERROR;
15.     }
17.     for (size_t i = 0; i < optionList.size(); i++) {
18.         const SubscribeOptions& opts = optionList[i];
19.         ALOGI("SubscriptionManager::addOrUpdateSubscription, prop: 0x%x", opts.propId);
20.         client->addOrUpdateSubscription(opts);
22.         addClientToPropMapLocked(opts.propId, client);
24.         if (SubscribeFlags::EVENTS_FROM_CAR & opts.flags) {
25.             SubscribeOptions updated;
26.             if (updateHalEventSubscriptionLocked(opts, &updated)) {
27.                 outUpdatedSubscriptions->push_back(updated);
28.             }
29.         }
30.     }
32.     return StatusCode::OK;
33. }

复制代码

起首，创建客户端对象HalClient

1. std::map<ClientId, sp<HalClient>> mClients;
3. sp<HalClient> SubscriptionManager::getOrCreateHalClientLocked(
4.         ClientId clientId, const sp<IVehicleCallback>& callback) {
5.     auto it = mClients.find(clientId);
7.     if (it == mClients.end()) {
8.         uint64_t cookie = reinterpret_cast<uint64_t>(clientId);
9.         ALOGI("Creating new client and linking to death recipient, cookie: 0x%" PRIx64, cookie);
10.         auto res = callback->linkToDeath(mCallbackDeathRecipient, cookie);
11.         if (!res.isOk()) {  // Client is already dead?
12.             ALOGW("%s failed to link to death, client %p, err: %s",
13.                   __func__, callback.get(), res.description().c_str());
14.             return nullptr;
15.         }
17.         sp<HalClient> client = new HalClient(callback);
18.         mClients.insert({clientId, client});
19.         return client;
20.     } else {
21.         return it->second;
22.     }
23. }

复制代码

mClients是保存订阅客户端的map，key是ClientId，value是HalClient对象。这里会先判断mClients这个map中是否存在对应的客户端，如果没有，则创建HalClient对象，并到场到这个map之中，如果有则直接返回。
然后for循环遍历所有的订阅项，由于订阅的时候，CarService传入的是SubscribeOptions的列表：

1. struct SubscribeOptions {
2.     /** Property to subscribe */
3.     int32_t propId;
5.     /**
6.      * Sample rate in Hz.
7.      *
8.      * Must be provided for properties with
9.      * VehiclePropertyChangeMode::CONTINUOUS. The value must be within
10.      * VehiclePropConfig#minSamplingRate .. VehiclePropConfig#maxSamplingRate
11.      * for a given property.
12.      * This value indicates how many updates per second client wants to receive.
13.      */
14.     float sampleRate;
16.     /** Flags that indicate to which event sources to listen. */
17.     SubscribeFlags flags;
18. };

复制代码

所以可以一次性订阅多个属性。但是这多个属性是一次订阅，也是走一个回调函数上去的。这里会遍历所有的SubscribeOptions，然后调用addOrUpdateSubscription函数。

1. std::map<int32_t, SubscribeOptions> mSubscriptions;
3. void HalClient::addOrUpdateSubscription(const SubscribeOptions &opts)  {
4.     ALOGI("%s opts.propId: 0x%x", __func__, opts.propId);
6.     auto it = mSubscriptions.find(opts.propId);
7.     if (it == mSubscriptions.end()) {
8.         mSubscriptions.emplace(opts.propId, opts);
9.     } else {
10.         const SubscribeOptions& oldOpts = it->second;
11.         SubscribeOptions updatedOptions;
12.         if (mergeSubscribeOptions(oldOpts, opts, &updatedOptions)) {
13.             mSubscriptions.erase(it);
14.             mSubscriptions.emplace(opts.propId, updatedOptions);
15.         }
16.     }
17. }
18. bool mergeSubscribeOptions(const SubscribeOptions &oldOpts,
19.                            const SubscribeOptions &newOpts,
20.                            SubscribeOptions *outResult) {
21.     float updatedRate = std::max(oldOpts.sampleRate, newOpts.sampleRate);
22.     SubscribeFlags updatedFlags = SubscribeFlags(oldOpts.flags | newOpts.flags);
24.     bool updated = (updatedRate > oldOpts.sampleRate) || (updatedFlags != oldOpts.flags);
25.     if (updated) {
26.         *outResult = oldOpts;
27.         outResult->sampleRate = updatedRate;
28.         outResult->flags = updatedFlags;
29.     }
31.     return updated;
32. }

复制代码

起首判断这个SubscribeOptions中包含的propId是否已经存在于mSubscriptions这个map中，如果存在，则更新flag和采样率和相应的SubscribeOptions对象，如果不存在，则添加。
这个map的key是propId，value是SubscribeOptions。

1. std::map<int32_t, sp<HalClientVector>> mPropToClients;
3. void SubscriptionManager::addClientToPropMapLocked(
4.         int32_t propId, const sp<HalClient> &client) {
5.     auto it = mPropToClients.find(propId);
6.     sp<HalClientVector> propClients;
7.     if (it == mPropToClients.end()) {
8.         propClients = new HalClientVector();
9.         mPropToClients.insert(std::make_pair(propId, propClients));
10.     } else {
11.         propClients = it->second;
12.     }
13.     propClients->addOrUpdate(client);
14. }

复制代码

mPropToClients是SubscriptionManager类中的一个map，key是propId，value是HalClientVector对象。HalClientVectot中存储的是对于同一个propId订阅的不同HalClient对象。
这里，先判断mPropToClients中是否有对应的propId的HalClientVector，如果没有，则表现这个propId没有客户端订阅过。如果有则将当前的client对象添加到HalClientVector中。
总结一下属性订阅做的事就是：

• 根据传入的callback指针，转换成ClientId，作为客户端标识
  
• 创建HalClient对象，作为客户端实例，并保存客户端的callback回调
  
• 缓存所有订阅属性到HalClient对象的mSubscriptions中
  
• 缓存HalClient到mClients这个map中
  
• 缓存HalClient到mPropToClients这个map中
  

4.2 连续范例属性订阅流程源码分析

连续范例属性，订阅之后必要VHAL周期性上报给CarService
连续属性订阅，其他和上面的普通订阅雷同，最后会走到EmulatedVehicleHal中进行处置惩罚

1. StatusCode EmulatedVehicleHal::subscribe(int32_t property, float sampleRate) {
2.     ALOGI("%s propId: 0x%x, sampleRate: %f", __func__, property, sampleRate);
4.     if (isContinuousProperty(property)) {
5.         mRecurrentTimer.registerRecurrentEvent(hertzToNanoseconds(sampleRate), property);
6.     }
7.     return StatusCode::OK;
8. }
10. bool EmulatedVehicleHal::isContinuousProperty(int32_t propId) const {
11.     const VehiclePropConfig* config = mPropStore->getConfigOrNull(propId);
12.     if (config == nullptr) {
13.         ALOGW("Config not found for property: 0x%x", propId);
14.         return false;
15.     }
16.     return config->changeMode == VehiclePropertyChangeMode::CONTINUOUS;
17. }

复制代码

重要就是通过属性设置的changeMode是否是CONTINUOUS来判断，判断如果还连续属性，调用registerRecurrentEvent

1. std::unordered_map<int32_t, RecurrentEvent> mCookieToEventsMap;
3. void registerRecurrentEvent(std::chrono::nanoseconds interval, int32_t cookie) {
4.     TimePoint now = Clock::now();
5.     // Align event time point among all intervals. Thus if we have two intervals 1ms and 2ms,
6.     // during every second wake-up both intervals will be triggered.
7.     TimePoint absoluteTime = now - Nanos(now.time_since_epoch().count() % interval.count());
9.     {
10.         std::lock_guard<std::mutex> g(mLock);
11.         mCookieToEventsMap[cookie] = { interval, cookie, absoluteTime };
12.     }
13.     mCond.notify_one();
14. }

复制代码

用propId作为key，将定时势件的定时周期，propId，当前转换后时间封装成RecurrentEvent对象，存储到mCookieToEventsMap这个map中，然后通过mCond叫醒线程，至此连续订阅完成，等待特定时间上报。
4.3 订阅流程图

plantuml

1. @startuml
3. participant CarService
4. box
5. participant VehicleHalManager
6. participant SubscriptionManager
7. participant HalClient
8. participant HalClientVector
9. participant EmulatedVehicleHal
10. participant RecurrentTimer
11. endbox
13. CarService -> VehicleHalManager: subscribe(const sp<IVehicleCallback> &callback, \n\tconst hidl_vec<SubscribeOptions> &options)
14. VehicleHalManager -> SubscriptionManager: addOrUpdateSubscription(\n\tClientId clientId, \n\tconst sp<IVehicleCallback> &callback, \n\tconst hidl_vec<SubscribeOptions> &optionList, \n\tstd::list<SubscribeOptions>* outUpdatedSubscriptions)
15. SubscriptionManager -> SubscriptionManager: getClientId(const sp<IVehicleCallback>& callback)
16. SubscriptionManager -> SubscriptionManager: getOrCreateHalClientLocked(ClientId clientId, \n\tconst sp<IVehicleCallback>& callback)
17. alt not in mClients
18.     SubscriptionManager -> HalClient: new HalClient(const sp<IVehicleCallback> &callback)
19.     HalClient -> SubscriptionManager: client
20.     SubscriptionManager -> SubscriptionManager: mClients.insert({clientId, client})
21. end
22. loop i in optionList.size
23.     SubscriptionManager -> HalClient: addOrUpdateSubscription(const SubscribeOptions &opts)
24.     alt not in mSubscriptions
25.         HalClient -> HalClient: emplace(opts.propId, opts)
26.     else in mSubscriptions
27.         HalClient -> HalClient: mergeSubscribeOptions(oldOpts, opts, &updatedOptions)
28.         HalClient -> HalClient: erase(it)
29.         HalClient -> HalClient: emplace(opts.propId, opts)
30.     end
31.     SubscriptionManager -> SubscriptionManager: addClientToPropMapLocked(opts.propId, client)
32.     alt not in mPropToClients
33.         SubscriptionManager -> HalClientVector: new HalClientVector()
34.         HalClientVector -> SubscriptionManager: propClients
35.         SubscriptionManager -> SubscriptionManager: mPropToClients.insert(std::make_pair(propId, propClients));
36.     end
37.     SubscriptionManager -> SubscriptionManager: propClients->addOrUpdate(client)
38. end
39. loop opt in updatedOptions
40.     SubscriptionManager -> EmulatedVehicleHal: subscribe(opt.propId, opt.sampleRate)
41.     alt isContinuousProperty
42.         EmulatedVehicleHal -> RecurrentTimer: registerRecurrentEvent(hertzToNanoseconds(sampleRate), property)
43.         RecurrentTimer -> RecurrentTimer: mCookieToEventsMap[cookie] = \n\t{ interval, cookie, absoluteTime }
44.     end
45. end
47. @enduml

复制代码

流程图如下：

5 取消订阅流程

5.1 取消订阅流程源码分析

取消订阅入口也是在VehicleHalManager中

1. Return<StatusCode> VehicleHalManager::unsubscribe(const sp<IVehicleCallback>& callback,
2.                                                   int32_t propId) {
3.     mSubscriptionManager.unsubscribe(getClientId(callback), propId);
4.     return StatusCode::OK;
5. }

复制代码

根据callback获取ClientId，并转到SubscriptionManager中处置惩罚

1. void SubscriptionManager::unsubscribe(ClientId clientId,
2.                                       int32_t propId) {
3.     MuxGuard g(mLock);
4.     auto propertyClients = getClientsForPropertyLocked(propId);
5.     auto clientIter = mClients.find(clientId);
6.     if (clientIter == mClients.end()) {
7.         ALOGW("Unable to unsubscribe: no callback found, propId: 0x%x", propId);
8.     } else {
9.         auto client = clientIter->second;
11.         if (propertyClients != nullptr) {
12.             propertyClients->remove(client);
14.             if (propertyClients->isEmpty()) {
15.                 mPropToClients.erase(propId);
16.             }
17.         }
19.         bool isClientSubscribedToOtherProps = false;
20.         for (const auto& propClient : mPropToClients) {
21.             if (propClient.second->indexOf(client) >= 0) {
22.                 isClientSubscribedToOtherProps = true;
23.                 break;
24.             }
25.         }
27.         if (!isClientSubscribedToOtherProps) {
28.             auto res = client->getCallback()->unlinkToDeath(mCallbackDeathRecipient);
29.             if (!res.isOk()) {
30.                 ALOGW("%s failed to unlink to death, client: %p, err: %s",
31.                       __func__, client->getCallback().get(), res.description().c_str());
32.             }
33.             mClients.erase(clientIter);
34.         }
35.     }
37.     if (propertyClients == nullptr || propertyClients->isEmpty()) {
38.         mHalEventSubscribeOptions.erase(propId);
39.         mOnPropertyUnsubscribed(propId);
40.     }
41. }
42. sp<HalClientVector> SubscriptionManager::getClientsForPropertyLocked(
43.         int32_t propId) const {
44.     auto it = mPropToClients.find(propId);
45.     return it == mPropToClients.end() ? nullptr : it->second;
46. }

复制代码

起首，调用getClientsForPropertyLocked函数，根据propId获取HalClientVector对象。然后从mClients中根据ClientId找到对应的HalClient对象，如果该HalClient存在，则从HalClientVector中移除，如果HalClientVector中是最后一个HalClient，则从mPropToClients中移除这个propId的HalClientVector对象。
如果这个client还订阅了其他propId，则不把这个client从mClients中移除，如果没有订阅其他的propId，则从mClients中移除。
同时，如果这个HalClientVector为空了，则移除mHalEventSubscribeOptions中的对应propId的订阅属性，并调用mOnPropertyUnsubscribed这个回调函数。

1. void VehicleHalManager::onAllClientsUnsubscribed(int32_t propertyId) {
2.     mHal->unsubscribe(propertyId);
3. }
5. StatusCode EmulatedVehicleHal::unsubscribe(int32_t property) {
6.     ALOGI("%s propId: 0x%x", __func__, property);
7.     if (isContinuousProperty(property)) {
8.         mRecurrentTimer.unregisterRecurrentEvent(property);
9.     }
10.     return StatusCode::OK;
11. }
13. void unregisterRecurrentEvent(int32_t cookie) {
14.         {
15.             std::lock_guard<std::mutex> g(mLock);
16.             mCookieToEventsMap.erase(cookie);
17.         }
18.         mCond.notify_one();
19.     }

复制代码

这个地方就是对连续属性的取消订阅处置惩罚，从mCookieToEventsMap中移除。
5.2 取消订阅流程图

plantuml

1. @startuml
3. participant CarService
4. box
5. participant VehicleHalManager
6. participant SubscriptionManager
7. participant EmulatedVehicleHal
8. participant RecurrentTimer
9. endbox
11. CarService -> VehicleHalManager: unsubscribe(const sp<IVehicleCallback>& callback,\n\t int32_t propId)
12. VehicleHalManager -> SubscriptionManager: unsubscribe(getClientId(callback), propId)
13. SubscriptionManager -> SubscriptionManager: propertyClients = getClientsForPropertyLocked(propId)
14. alt client in mClients
15.     SubscriptionManager -> SubscriptionManager: propertyClients->remove(client)
16.     alt propertyClients->isEmpty()
17.         SubscriptionManager -> SubscriptionManager: mPropToClients.erase(propId)
18.     end
19.     loop propClient in mPropToClients
20.         alt client in propClient
21.             SubscriptionManager -> SubscriptionManager: isClientSubscribedToOtherProps = true
22.         end
23.     end
24.     alt isClientSubscribedToOtherProps == false
25.         SubscriptionManager -> SubscriptionManager: client->getCallback()->\n\tunlinkToDeath(mCallbackDeathRecipient)
26.     end
27. end
28. alt propertyClients == nullptr || propertyClients->isEmpty()
29.     SubscriptionManager -> VehicleHalManager: onAllClientsUnsubscribed(propertyId)
30.     VehicleHalManager -> EmulatedVehicleHal: unsubscribe(property)
31.     alt isContinuousProperty
32.         EmulatedVehicleHal -> RecurrentTimer: unregisterRecurrentEvent(property)
33.         RecurrentTimer -> RecurrentTimer: mCookieToEventsMap.erase(cookie)
34.     end
35. end
37. @enduml

复制代码

流程图：

6 属性上报流程

6.1 属性上报流程源码分析

1. void onPropertyValueFromCar(const VehiclePropValue& value, bool updateStatus) override {
2.     return this->onPropertyValue(value, updateStatus);
3. }

复制代码

由于EmulatedVehicleConnector同时继承VehicleHalServer和VehicleHalClient，所以这个onPropertyValue继承于VehicleHalClient，调用的是VehicleHalClient中的onPropertyValue函数。

1. void VehicleHalClient::onPropertyValue(const VehiclePropValue& value, bool updateStatus) {
2.     if (!mPropCallback) {
3.         LOG(ERROR) << __func__ << ": PropertyCallBackType is not registered!";
4.         return;
5.     }
6.     return mPropCallback(value, updateStatus);
7. }

复制代码

调用mPropCallback这个注册的回调函数，这个回调函数是：

1. void EmulatedVehicleHal::onPropertyValue(const VehiclePropValue& value, bool updateStatus) {
2.     VehiclePropValuePtr updatedPropValue = getValuePool()->obtain(value);
4.     if (mPropStore->writeValue(*updatedPropValue, updateStatus)) {
5.         getEmulatorOrDie()->doSetValueFromClient(*updatedPropValue);
6.         doHalEvent(std::move(updatedPropValue));
7.     }
8. }

复制代码

起首，将上报的属性写入缓存中。然后调用doSetValueFromClient

1. void VehicleEmulator::doSetValueFromClient(const VehiclePropValue& propValue) {
2.     vhal_proto::EmulatorMessage msg;
3.     vhal_proto::VehiclePropValue* val = msg.add_value();
4.     populateProtoVehiclePropValue(val, &propValue);
5.     msg.set_status(vhal_proto::RESULT_OK);
6.     msg.set_msg_type(vhal_proto::SET_PROPERTY_ASYNC);
8.     mSocketComm->sendMessage(msg);
9.     if (mPipeComm) {
10.         mPipeComm->sendMessage(msg);
11.     }
12. }

复制代码

这里会通过SocketComm和PipeComm通知其他客户端。
然后会调用doHalEvent上报给CarService。

1. void doHalEvent(VehiclePropValuePtr v) {
2.     mOnHalEvent(std::move(v));
3. }

复制代码

mOnHalEvent是VehicleHalManager:nHalEvent函数

1. void VehicleHalManager::onHalEvent(VehiclePropValuePtr v) {
2.     mEventQueue.push(std::move(v));
3. }

复制代码

将VehiclePropValuePtr传入mEventQueue，这个是初始化的时候与BatchingConsumer中的mQueue绑定的一个queue，用于处置惩罚上报事件。同时BatchingConsumer这个类初始化的时候也会创建一个线程来处置惩罚上报事件，运行的函数为：

1. void runInternal(const OnBatchReceivedFunc& onBatchReceived) {
2.     if (mState.exchange(State::RUNNING) == State::INIT) {
3.         while (State::RUNNING == mState) {
4.             mQueue->waitForItems();
5.             if (State::STOP_REQUESTED == mState) break;
7.             std::this_thread::sleep_for(mBatchInterval);
8.             if (State::STOP_REQUESTED == mState) break;
10.             std::vector<T> items = mQueue->flush();
12.             if (items.size() > 0) {
13.                 onBatchReceived(items);
14.             }
15.         }
16.     }
18.     mState = State::STOPPED;
19. }
21. void waitForItems() {
22.     std::unique_lock<std::mutex> g(mLock);
23.     while (mQueue.empty() && mIsActive) {
24.         mCond.wait(g);
25.     }
26. }
28. std::vector<T> flush() {
29.     std::vector<T> items;
31.     MuxGuard g(mLock);
32.     if (mQueue.empty() || !mIsActive) {
33.         return items;
34.     }
35.     while (!mQueue.empty()) {
36.         items.push_back(std::move(mQueue.front()));
37.         mQueue.pop();
38.     }
39.     return items;
40. }
42. void push(T&& item) {
43.     {
44.         MuxGuard g(mLock);
45.         if (!mIsActive) {
46.             return;
47.         }
48.         mQueue.push(std::move(item));
49.     }
50.     mCond.notify_one();
51. }

复制代码

当没有上报事件时，会waitForItems壅闭线程。如果有事件，则会在循环中处置惩罚，等待一个时间间隔mBatchInterval=10，如果在这个事件内没有上报事件，会等10s，如果有，则会在push的时候立马叫醒线程实行。
然后将queue中的所有事件都取出，调用回调函数处置惩罚，回调函数是：

1. void VehicleHalManager::onBatchHalEvent(const std::vector<VehiclePropValuePtr>& values) {
2.     const auto& clientValues =
3.         mSubscriptionManager.distributeValuesToClients(values, SubscribeFlags::EVENTS_FROM_CAR);
5.     for (const HalClientValues& cv : clientValues) {
6.         auto vecSize = cv.values.size();
7.         hidl_vec<VehiclePropValue> vec;
8.         if (vecSize < kMaxHidlVecOfVehiclPropValuePoolSize) {
9.             vec.setToExternal(&mHidlVecOfVehiclePropValuePool[0], vecSize);
10.         } else {
11.             vec.resize(vecSize);
12.         }
14.         int i = 0;
15.         for (VehiclePropValue* pValue : cv.values) {
16.             shallowCopy(&(vec)[i++], *pValue);
17.         }
18.         auto status = cv.client->getCallback()->onPropertyEvent(vec);
19.         if (!status.isOk()) {
20.             ALOGE("Failed to notify client %s, err: %s",
21.                   toString(cv.client->getCallback()).c_str(),
22.                   status.description().c_str());
23.         }
24.     }
25. }

复制代码

先看下封装

1. std::list<HalClientValues> SubscriptionManager::distributeValuesToClients(
2.         const std::vector<recyclable_ptr<VehiclePropValue>>& propValues,
3.         SubscribeFlags flags) const {
4.     //创建一个map，key是HalClient，value是VehiclePropValue
5.     std::map<sp<HalClient>, std::list<VehiclePropValue*>> clientValuesMap;
7.     {
8.         MuxGuard g(mLock);
9.         //遍历所有的propValue
10.         for (const auto& propValue: propValues) {
11.             VehiclePropValue* v = propValue.get();
12.             //获取所有订阅了该属性的客户端HalClient对象
13.             auto clients = getSubscribedClientsLocked(v->prop, flags);
14.             //遍历所有HalClient，并将其和propValue一起封装加入clientValuesMap中
15.             for (const auto& client : clients) {
16.                 clientValuesMap[client].push_back(v);
17.             }
18.         }
19.     }
21.         //遍历map中所有的对象，并封装成HalClientValues对象，存入clientValues中
22.     std::list<HalClientValues> clientValues;
23.     for (const auto& entry : clientValuesMap) {
24.         clientValues.push_back(HalClientValues {
25.             .client = entry.first,
26.             .values = entry.second
27.         });
28.     }
30.     return clientValues;
31. }
33. std::list<sp<HalClient>> SubscriptionManager::getSubscribedClientsLocked(
34.     int32_t propId, SubscribeFlags flags) const {
35.     std::list<sp<HalClient>> subscribedClients;
36.        
37.         //通过propId获取该id对应的HalClientVector对象
38.     sp<HalClientVector> propClients = getClientsForPropertyLocked(propId);
39.     if (propClients.get() != nullptr) {
40.             //遍历HalClientVector中HalClient，并返回
41.         for (size_t i = 0; i < propClients->size(); i++) {
42.             const auto& client = propClients->itemAt(i);
43.             if (client->isSubscribed(propId, flags)) {
44.                 subscribedClients.push_back(client);
45.             }
46.         }
47.     }
49.     return subscribedClients;
50. }
52. sp<HalClientVector> SubscriptionManager::getClientsForPropertyLocked(
53.         int32_t propId) const {
54.     auto it = mPropToClients.find(propId);
55.     return it == mPropToClients.end() ? nullptr : it->second;
56. }

复制代码

对客户端和属性值进行封装，然后遍历封装后的数组，逐个调用其回调函数onPropertyEvent，这个就是客户端传入的回调函数。
6.2 连续属性上报流程源码分析

连续属性订阅之后，会根据传入的采样率转换后的频率进行上报，订阅时，将订阅事件保存在mCookieToEventsMap这个map中，并叫醒了处置惩罚线程。
这个线程是什么时候初始化，在实行什么呢？这个可以参考https://editor.csdn.net/md/?articleId=140752076

1. void loop(const Action& action) {
2.     static constexpr auto kInvalidTime = TimePoint(Nanos::max());
4.     std::vector<int32_t> cookies;
6.     while (!mStopRequested) {
7.         auto now = Clock::now();
8.         auto nextEventTime = kInvalidTime;
9.         cookies.clear();
11.         {
12.             std::unique_lock<std::mutex> g(mLock);
14.             for (auto&& it : mCookieToEventsMap) {
15.                 RecurrentEvent& event = it.second;
16.                 if (event.absoluteTime <= now) {
17.                     event.updateNextEventTime(now);
18.                     cookies.push_back(event.cookie);
19.                 }
21.                 if (nextEventTime > event.absoluteTime) {
22.                     nextEventTime = event.absoluteTime;
23.                 }
24.             }
25.         }
27.         if (cookies.size() != 0) {
28.             action(cookies);
29.         }
31.         std::unique_lock<std::mutex> g(mLock);
32.         mCond.wait_until(g, nextEventTime);  // nextEventTime can be nanoseconds::max()
33.     }
34. }

复制代码

叫醒这个线程，并在这个内里从mCookieToEventsMap中取出RecurrentEvent，判断时间戳，如果已经到时了，则实行内里的action回调函数。

1. void EmulatedVehicleHal::onContinuousPropertyTimer(const std::vector<int32_t>& properties) {
2.     VehiclePropValuePtr v;
4.     auto& pool = *getValuePool();
6.     for (int32_t property : properties) {
7.         if (isContinuousProperty(property)) {
8.             auto internalPropValue = mPropStore->readValueOrNull(property);
9.             if (internalPropValue != nullptr) {
10.                 v = pool.obtain(*internalPropValue);
11.             }
12.         } else {
13.             ALOGE("Unexpected onContinuousPropertyTimer for property: 0x%x", property);
14.         }
16.         if (v.get()) {
17.             v->timestamp = elapsedRealtimeNano();
18.             doHalEvent(std::move(v));
19.         }
20.     }
21. }

复制代码

如果是连续属性，则从VehiclePropertyStore读取缓存，并调用doHalEvent往上报，这个和6.1节中的上报流程雷同。
6.3 属性上报流程图

plantuml

1. @startuml
3. participant CarService
4. box
5. participant EmulatedVehicleHal
6. participant VehicleHalManager
7. participant SubscriptionManager
8. participant HalClient
9. participant IPassThroughConnector
10. participant VehicleHalClient
11. participant VehiclePropertyStore
12. participant VehicleEmulator
13. participant SocketComm
14. participant ConcurrentQueue
15. participant BatchingConsumer
16. endbox
18. EmulatedVehicleHal -> IPassThroughConnector: onPropertyValueFromCar(*updatedPropValue, updateStatus)
19. IPassThroughConnector -> VehicleHalClient: onPropertyValue(value, updateStatus)
20. VehicleHalClient -> EmulatedVehicleHal: onPropertyValue(value, updateStatus)
21. EmulatedVehicleHal -> VehiclePropertyStore: writeValue(*updatedPropValue, updateStatus)
22. alt writeValue success
23.     EmulatedVehicleHal -> VehicleEmulator: doSetValueFromClient(*updatedPropValue)
24.     VehicleEmulator -> SocketComm: sendMessage(msg)
25.     EmulatedVehicleHal -> EmulatedVehicleHal: doHalEvent(std::move(updatedPropValue))
26.     EmulatedVehicleHal -> VehicleHalManager::onHalEvent(updatedPropValue)
27.     VehicleHalManager -> VehicleHalManager: mEventQueue.push(std::move(updatedPropValue))
28.     VehicleHalManager -> ConcurrentQueue: mQueue.push(updatedPropValue)
29.     ConcurrentQueue -> ConcurrentQueue: mCond.notify_one()
30.     ConcurrentQueue -> BatchingConsumer: runInternal(const OnBatchReceivedFunc& onBatchReceived)
31.     BatchingConsumer -> VehicleHalManager: onBatchHalEvent(const std::vector<VehiclePropValuePtr>& values)
32.     VehicleHalManager -> SubscriptionManager: distributeValuesToClients(values, \n\tSubscribeFlags::EVENTS_FROM_CAR)
33.     SubscriptionManager -> VehicleHalManager: clientValues
34.     loop cv in clientValues
35.         VehicleHalManager -> HalClient: getCallback()
36.         HalClient -> VehicleHalManager: callback
37.         VehicleHalManager -> CarService: callback->onPropertyEvent(values)
38.     end
39. end
41. @enduml

复制代码

流程图

连续属性上报流程图省略，大致和这个上面差不多，只是触发在定时器中。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。