OpenHarmony-5.PM 子体系（2）

• 电池服务组件
  
• OpenHarmony-4.1-Release
  

1.电池服务组件
  Battery Manager 提供了电池信息查询的接口，同时开发者也可以通过公共事故监听电池状态和充放电状态的变革。电池服务组件提供如下功能：

• 电池信息查询。
  
• 充放电状态查询。
  
• 关机充电。
  

  电池服务组件架构图：

1.1.代码目次:

1. base/powermgr/battery_manager
2. ├── figures                          # 架构图
3. ├── frameworks                  # Framework层
4. │   ├── napi                         # NAPI
5. │   └── native                  # Native层
6. ├── interfaces                  # 接口层
7. │   └── inner_api               # 内部接口
8. ├── sa_profile                  # SA配置文件
9. ├── services                    # 服务层
10. │   ├── native                  # Native层
11. │   └── zidl                    # Zidl接口层
12. ├── test                        # 测试用例
13. │   ├── fuzztest                # Fuzz 测试
14. │   ├── unittest                # 单元测试
15. │   ├── systemtest              # 系统测试
16. │   └── utils                   # 测试工具
17. └── utils                       # 工具和通用层
18. base/powermgr/battery_manager
19. ├── figures                          # 架构图
20. ├── frameworks                  # Framework层
21. │   ├── napi                         # NAPI
22. │   └── native                  # Native层
23. ├── interfaces                  # 接口层
24. │   └── inner_api               # 内部接口
25. ├── sa_profile                  # SA配置文件
26. ├── services                    # 服务层
27. │   ├── native                  # Native层
28. │   └── zidl                    # Zidl接口层
29. ├── test                        # 测试用例
30. │   ├── fuzztest                # Fuzz 测试
31. │   ├── unittest                # 单元测试
32. │   ├── systemtest              # 系统测试
33. │   └── utils                   # 测试工具
34. └── utils                       # 工具和通用层

复制代码

1.2.电池和充电属性接口
  该模块主要提供电池状态和充放电状态的查询接口。batteryInfo类用来描述电池信息。

• powermgr_battery_manager\interfaces\inner_api\native\include\battery_info.h
  

1.3.Battery Service 服务启动
  Battery Service 服务被打包到 foundation 进程。System Ability 管理模块用于管理体系基础本领，本服务需要向该模块注册，如果没有编写 profile 配置，则 System Ability 管理模块在启动时不会注册该服务。

1. powermgr_battery_manager\sa_profile\3302.json
2. 注册信息：
3.   1 {
4.   2     "process": "foundation",
5.   3     "systemability": [
6.   4         {
7.   5             "name": 3302,
8.   6             "libpath": "libbatteryservice.z.so",
9.   7             "run-on-create": true,
10.   8             "distributed": false,
11.   9             "dump_level": 1
12. 10         }
13. 11     ]
14. 12 }

复制代码

• name：为对应的serviceId必须与代码中注册的serviceId保持一致；电池服务组件的serviceId为3302；
  
• libpath：为SystemAbility的加载路径，必配项；
  
• run-on-create：true表示进程启动后即向samgr组件注册该SystemAbility；false表示按需启动，即在其他模块访问到该SystemAbility时启动；必配项；
  
• distributed：true表示该SystemAbility为分布式SystemAbility，支持跨设备访问；false表示只有本地跨IPC访问；
  
• dump-level：表示systemdumper支持的level品级，默认配置1就OK；
  
• 注册信息配置文件：/system/profile/foundation.xml
  

1.3.1.注册代码

1. powermgr_battery_manager\services\native\src\battery_service.cpp
2. //调用SystemAbility接口注册BatteryService实例
3. const bool G_REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
4.     DelayedSpSingleton<BatteryService>::GetInstance().GetRefPtr());
5. //构建入参为serviceid、runoncreate
6. BatteryService::BatteryService()
7.     : SystemAbility(POWER_MANAGER_BATT_SERVICE_ID, true) {}

复制代码

  System Ability 管理模块调用 BatteryService 的启动函数实现电池服务组件的启动：

1. powermgr_battery_manager\services\native\src\battery_service.cpp
2. void BatteryService::OnStart()
3. {
4.     //如果已启动则返回（BatteryService是单实例服务，只会启动一个）
5.     if (ready_) {
6.         BATTERY_HILOGD(COMP_SVC, "Service is ready, nothing to do");
7.         return;
8.     }
9.     //创建BatterysrvEventHandler实例
10.     //等待CommonEventService服务启动完成之后初始化完成
11.     if (!(Init())) {         //调用BatteryService::Init
12.         BATTERY_HILOGE(COMP_SVC, "Call init failed");
13.         return;
14.     }
15.     //向OHOS::HDI::ServiceManager 注册状态监听
16.     RegisterHdiStatusListener();
17.    //BatteryService服务发布到System Ability管理模块
18.     if (!Publish(this)) {
19.         BATTERY_HILOGE(COMP_SVC, "Register to system ability manager failed");
20.         return;
21.     }
22.     // 对指定SA，MISCDEVICE_SERVICE_ABILITY_ID 的监听，当监听的该SA已被publish到SAmgr后，就会触发OnAddSystemAbility
23.     AddSystemAbilityListener(MISCDEVICE_SERVICE_ABILITY_ID);
24.     ready_ = true;
25. }

复制代码

  重点分析：

• BatteryService::Init
  

1. bool BatteryService::Init()
2. {
3.     InitConfig();        //解析battery_config.json
4.     if (!batteryNotify_) {
5.         batteryNotify_ = std::make_unique<BatteryNotify>();
6.     }
7.     VibratorInit();     //解析battery_vibrator.json
8.     RegisterBootCompletedCallback();
9.     return true;
10. }

复制代码

• RegisterHdiStatusListener();
  

1. ->RegisterBatteryHdiCallback();
2.    ->ErrCode ret = iBatteryInterface_->Register(callback);
3.         //drivers_peripheral\battery\interfaces\hdi_service\src\battery_interface_impl.cpp
4.                    (即 BatteryInterfaceImpl::Register(const sptr<IBatteryCallback>& callback))

复制代码

1.3.2.BatteryInterfaceDriver 启动
  BatteryInterfaceDriver 是 HDI（即驱动接口）层服务，打包在 power_host 进程。本文主要分析 batteryd 的实现。
  device_info.hcs 节点配置：

1. /vendor/hihope/rk3568/hdf_config/uhdf/device_info.hcs
2. 140         power :: host {
3. 141             hostName = "power_host";
4. 142             priority = 50;
5. 143             uid = "power_host";
6. 144             gid = ["power_host", "system", "log"];
7. 145             caps = ["BLOCK_SUSPEND"];
8. 146             power_device :: device {
9. 147                 device0 :: deviceNode {
10. 148                     policy = 2;
11. 149                     priority = 100;
12. 150                     moduleName = "libpower_driver.z.so";
13. 151                     serviceName = "power_interface_service";
14. 152                 }
15. 153             }
16. 154             battery_device :: device {
17. 155                 device0 :: deviceNode {
18. 156                     policy = 2;
19. 157                     priority = 100;
20. 158                     moduleName = "libbattery_driver.z.so";
21. 159                     serviceName = "battery_interface_service";
22. 160                 }
23. 161             }
24. 162             thermal_device :: device {
25. 163                 device0 :: deviceNode {
26. 164                     policy = 2;
27. 165                     priority = 100;
28. 166                     moduleName = "libthermal_driver.z.so";
29. 167                     serviceName = "thermal_interface_service";
30. 168                 }
31. 169             }
32. 170         }

复制代码

  驱动程序 (Driver Entry)入口中的三个主要接口：

• Bind 接口：实现驱动接口实例化绑定，如果需要发布驱动接口，会在驱动加载过程中被调用，实例化该接口的驱动服务并和 DeviceObject 绑定。
  
• Init 接口：实现驱动的初始化，返回错误将中断驱动加载流程。
  
• Release 接口：实现驱动的卸载，在该接口中开释驱动实例的软硬件资源。
  

  batteryd 驱动程序初始化接口：

1. drivers_peripheral\battery\interfaces\hdi_service\src\battery_interface_driver.cpp
2. static struct HdfDriverEntry g_batteryInterfaceDriverEntry = {
3.     .moduleVersion = 1,
4.     .moduleName = "battery_interface_service",
5.     .Bind = HdfBatteryInterfaceDriverBind,
6.     .Init = HdfBatteryInterfaceDriverInit,
7.     .Release = HdfBatteryInterfaceDriverRelease,
8. };
11. static int32_t HdfBatteryInterfaceDriverBind(struct HdfDeviceObject *deviceObject)
12. {
13.     auto *hdfBatteryInterfaceHost = new (std::nothrow) HdfBatteryInterfaceHost;
15.     //绑定BatteryInterfaceDriverDispatch作为消息处理函数。
16.     hdfBatteryInterfaceHost->ioService.Dispatch = BatteryInterfaceDriverDispatch;
17.     hdfBatteryInterfaceHost->ioService.Open = nullptr;
18.     hdfBatteryInterfaceHost->ioService.Release = nullptr;
20.     auto serviceImpl = IBatteryInterface::Get(true);
22.     hdfBatteryInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl,
23.         IBatteryInterface::GetDescriptor());
25.     //IO Service 完成 IPC 通信的客户端消息请求封装，IO Dispatcher 完成驱动服务端消息请求封装
26.     //客户端消息通过 IPC 通信到达服务端并分发给 IO Dispatcher 处理。
27.     deviceObject->service = &hdfBatteryInterfaceHost->ioService;
28.     return HDF_SUCCESS;
29. }

复制代码

  BatteryInterfaceImpl接口：
  通过调用BatteryInterfaceImplGetInstance接口实例BatteryInterfaceImpl对象，并且调用调用BatteryInterfaceImpl::Init进行初始化。

• 初始化电池信息路径；
  
• 调用调用BatteryThread::StartThread.
  

1. drivers_peripheral\battery\interfaces\hdi_service\src\battery_interface_impl.cpp
2. extern "C" IBatteryInterface *BatteryInterfaceImplGetInstance(void)
3. {
4.     using OHOS::HDI::Battery::V2_0::BatteryInterfaceImpl;
5.     BatteryInterfaceImpl *service = new (std::nothrow) BatteryInterfaceImpl();
7.     if (service->Init() != HDF_SUCCESS) {  //调用BatteryInterfaceImpl::Init
8.         delete service;
9.         return nullptr;
10.     }
12.     return service;
13. }
15. int32_t BatteryInterfaceImpl::Init()
16. {
17.     powerSupplyProvider_ = std::make_unique<OHOS::HDI::Battery::V2_0::PowerSupplyProvider>();
19.     powerSupplyProvider_->InitBatteryPath();
20.     powerSupplyProvider_->InitPowerSupplySysfs();
22.     auto& batteryConfig = BatteryConfig::GetInstance();
24.     batteryConfig.ParseConfig();
26.     loop_ = std::make_unique<OHOS::HDI::Battery::V2_0::BatteryThread>();
28.     if (batteryCallback_ != nullptr) {
29.         loop_->InitCallback(batteryCallback_);
30.     } else {
31.         BATTERY_HILOGW(COMP_HDI, "batteryCallback_ is nullptr");
32.     }
33.     loop_->StartThread(this);  //调用BatteryThread::StartThread
35.     return HDF_SUCCESS;
36. }
38. drivers_peripheral\battery\interfaces\hdi_service\src\battery_thread.cpp
39. //在BatteryInterfaceImpl::Init() 启动初始化阶段启动本线程，用于处理kernel发来的消息
40. void BatteryThread::StartThread(void* service)
41. {
42.     Init(service);
43.     Run(service);
44. }

复制代码

1.3.3.电池 batteryInfo 信息查询流程
  采用NAPI （Native API）获取电池信息，NAPI 组件是一套对外接口基于Node.js N-API规范开发的原生模块扩展开发框架。NAPI组件架构图:

  NAPI得当封装IO、CPU麋集型、OS底层等本领并对外袒露JS接口，通过NAPI可以实现JS与C/C++代码互相访问。我们可以通过NAPI接口构建例如网络通讯、串口访问、多媒体解码、传感器数据网络等模块。接口实现详见：foundation/arkui/napi。

1. powermgr_battery_manager\frameworks\napi\battery_info.cpp:
2. static napi_module g_module = {.nm_version = 1,
3.     .nm_flags = 0,
4.     .nm_filename = "batteryInfo",
5.     .nm_register_func = BatteryInit,
6.     .nm_modname = "batteryInfo",
7.     .nm_priv = ((void*)0),
8.     .reserved = {0}};
10. extern "C" __attribute__((constructor)) void RegisterModule(void)
11. {
12.     napi_module_register(&g_module);
13. }

复制代码

• BatteryInit
  

1. static napi_value BatteryInit(napi_env env, napi_value exports)
2. {
3.     BATTERY_HILOGD(COMP_FWK, "Enter");
5.     napi_property_descriptor desc[] = {
6.         DECLARE_NAPI_GETTER("batterySOC", BatterySOC),
7.         DECLARE_NAPI_GETTER("chargingStatus", GetChargingState),
8.         DECLARE_NAPI_GETTER("healthStatus", GetHealthState),
9.         DECLARE_NAPI_GETTER("pluggedType", GetPluggedType),
10.         DECLARE_NAPI_GETTER("voltage", GetVoltage),
11.         DECLARE_NAPI_GETTER("technology", GetTechnology),
12.         DECLARE_NAPI_GETTER("batteryTemperature", GetBatteryTemperature),
13.         DECLARE_NAPI_GETTER("isBatteryPresent", GetBatteryPresent),
14.         DECLARE_NAPI_GETTER("batteryCapacityLevel", GetCapacityLevel),
15.         DECLARE_NAPI_GETTER("estimatedRemainingChargeTime", GetRemainingChargeTime),
16.         DECLARE_NAPI_GETTER("nowCurrent", GetBatteryNowCurrent),
17.         DECLARE_NAPI_GETTER("remainingEnergy", GetBatteryRemainEnergy),
18.         DECLARE_NAPI_GETTER("totalEnergy", GetTotalEnergy),
19.         DECLARE_NAPI_FUNCTION("setBatteryConfig", SetBatteryConfig),
20.         DECLARE_NAPI_FUNCTION("getBatteryConfig", GetBatteryConfig),
21.         DECLARE_NAPI_FUNCTION("isBatteryConfigSupported", IsBatteryConfigSupported),
22.     };
23.     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
25.     CreateEnumPluggedType(env, exports);
26.     CreateEnumChargeState(env, exports);
27.     CreateEnumHealthState(env, exports);
28.     CreateEnumLevelState(env, exports);
29.     CreateEventBatteryChangedKey(env, exports);
30.     CreateEventBatteryChangedCode(env, exports);
32.     BATTERY_HILOGD(COMP_FWK, "Success");
34.     return exports;
35. }

复制代码

  应用调用接口获取当前设备剩余电池容量（batterySOC）为例：

1. applications/standard/app_samples/code/SystemFeature/DeviceManagement/DeviceManagementCollection/feature/capabilities/src/main/ets/util/
2. //导入模块
3. import batteryInfo from '@ohos.batteryInfo';
5. 60   /**
6. 61    * 获取当前设备剩余电池电量百分比
7. 62    */
8. 63   public getBatterySOC(): string {
9. 64     let soc: number = this.disposeBatterySOC(batteryInfo.batterySOC)   //调用batterySOC查询接口
10. 65     logger.info(`${this.TAG} getChargingStatus: ${soc}`)
11. 66     return soc.toString()
12. 67   }
13. 68

复制代码

  NAPI 接口实现BatterySOC，BatterySOC调用流程：

1. g_battClient.GetCapacity()；
2. ->BatterySrvClient::GetCapacity()
3.    ->BatteryService::GetCapacity()
4.             ->BatteryInterface::GetCapacity(capacity)
5.                     -> PowerSupplyProvider::ParseCapacity
6.                        ->PowerSupplyProvider::ReadBatterySysfsToBuff
7.                                 ->open

复制代码

  详细分析：

1. powermgr_battery_manager\frameworks\napi\battery_info.cpp
2. thread_local static BatterySrvClient& g_battClient = BatterySrvClient::GetInstance();
3. //注册在动态库中的BatterySOC接口，实现了电池容量的查询
4. static napi_value BatterySOC(napi_env env, napi_callback_info info)
5. {
6.     napi_value napiValue = nullptr;
7.     int32_t capacity = g_battClient.GetCapacity();
9.     NAPI_CALL(env, napi_create_int32(env, capacity, &napiValue));
11.     BATTERY_HILOGD(FEATURE_BATT_INFO, "capacity %{public}d", capacity);
12.     return napiValue;
13. }
15. powermgr_battery_manager\frameworks\native\src\battery_srv_client.cpp
16. int32_t BatterySrvClient::GetCapacity()
17. {
18.     auto proxy = Connect();
19.    
20.     //查找到到POWER_MANAGER_BATT_SERVICE_ID（即BatteryService）服务并赋值给proxy_
21.     //需要了解SystemAbility IPC机制，xxClient-->xxProxy-->xxStub-->xxService。
22.     RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
23.     //调用BatteryService::GetCapacity()
24.     return proxy->GetCapacity();
25. }
27. powermgr_battery_manager\services\native\src\battery_service.cpp
28. int32_t BatteryService::GetCapacity()
29. {
30.     if (isMockCapacity_) {
31.         BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock battery capacity");
32.         return batteryInfo_.GetCapacity();
33.     }
34.     std::shared_lock<std::shared_mutex> lock(mutex_);
35.     if (iBatteryInterface_ == nullptr) {
36.         BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr");
37.         return ERR_NO_INIT;
38.     }
39.     int32_t capacity = BATTERY_FULL_CAPACITY;
40.     //调用 BatteryInterface::GetCapacity(capacity)
41.     iBatteryInterface_->GetCapacity(capacity);
42.     return capacity;
43. }
45. drivers_peripheral\battery\interfaces\hdi_service\src\battery_interface_impl.cpp
46. // BatteryInterfaceImpl 实现IBatteryInterface的纯虚函数
47. int32_t BatteryInterfaceImpl::GetCapacity(int32_t& capacity)
48. {
49.    // 调用 PowerSupplyProvider::ParseCapacity(...)
50.     return powerSupplyProvider_->ParseCapacity(&capacity);
51. }
53. drivers_peripheral\battery\interfaces\hdi_service\src\power_supply_provider.cpp
54. int32_t PowerSupplyProvider::ParseCapacity(int32_t* capacity) const
55. {
56.     char buf[MAX_BUFF_SIZE] = {0};
57.     // 从capacity的系统文件读取当前设备剩余电池容量中至buf
58.     int32_t ret = ReadBatterySysfsToBuff(batterySysfsInfo_.capacityPath.c_str(), buf, sizeof(buf));
59.     if (ret != HDF_SUCCESS) {
60.         return ret;
61.     }
62.      // 转换为十进制
63.     int32_t value = ParseInt(buf);
64.     *capacity = value;
66.     return HDF_SUCCESS;
67. }
69. int32_t PowerSupplyProvider::ReadBatterySysfsToBuff(const char* path, char* buf, size_t size) const
70. {  
71.     // ReadSysfsFile
72.     int32_t ret = ReadSysfsFile(path, buf, size);
73.     return HDF_SUCCESS;
74. }
76. int32_t PowerSupplyProvider::ReadSysfsFile(const char* path, char* buf, size_t size) const
77. {
78.     int32_t fd = open(path, O_RDONLY, S_IRUSR | S_IRGRP | S_IROTH);
80.     size_t readSize = read(fd, buf, size - 1);
81.     buf[readSize] = '\0';
82.     Trim(buf);
83.     close(fd);
85.     return HDF_SUCCESS;
86. }

复制代码

1.3.4.电池 batteryinfo 信息变更发布流程
  BatteryThread接口：

1. drivers_peripheral\battery\interfaces\hdi_service\src\battery_thread.cpp
2. int32_t BatteryThread::Init([[maybe_unused]] void* service)
3. {
4.     provider_ = std::make_unique<PowerSupplyProvider>();
5.     if (provider_ != nullptr) {
6.         provider_->InitBatteryPath();
7.         provider_->InitPowerSupplySysfs();
8.     }
9.     epFd_ = epoll_create1(EPOLL_CLOEXEC);  //创建epoll 实例，用于异步事件通知
10.     InitUevent();      //初始化uevent, 并且注册回调函数UeventCallback
11.     return HDF_SUCCESS;
12. }
14. void BatteryThread::Run(void* service)
15. {
16.     batteryThread_ = std::make_unique<std::thread>([this, service] { this->LoopingThreadEntry(service); });
17.     pthread_setname_np(batteryThread_->native_handle(), "battery_thread");
18. }
20. void BatteryThread::LoopingThreadEntry(void* arg)
21. {
22.     int32_t nevents = 0;
23.     size_t size = callbacks_.size();
24.     struct epoll_event events[size];
26.     while (isRunning_) {
27.         if (!nevents) {
28.             CycleMatters();
29.         }
31.         HandleStates();
33.         int32_t timeout = epollInterval_;
34.         int32_t waitTimeout = UpdateWaitInterval();
35.         if ((timeout < 0) || (waitTimeout > 0 && waitTimeout < timeout)) {
36.             timeout = waitTimeout;
37.         }
38.         // 等待监听的所有的fd相应的事件的产生
39.         nevents = epoll_wait(epFd_, events, static_cast<int32_t>(size), timeout);
40.         if (nevents <= 0) {
41.             continue;
42.         }
43.        // 在callbacks_中，根据ueventFd_， 调用void BatteryThread::UeventCallback(void* service)
44.         for (int32_t n = 0; n < nevents; ++n) {
45.             if (events[n].data.ptr) {
46.                 auto* func = const_cast<BatteryThread*>(this);
47.                 (callbacks_.find(events[n].data.fd)->second)(func, arg);
48.             }
49.         }
50.     }
51. }
53. //当监听到异步事件之后，调用该函数处理
54. void BatteryThread::UeventCallback(void* service)
55. {
56.     char msg[UEVENT_MSG_LEN + UEVENT_RESERVED_SIZE] = { 0 };
58.     ssize_t len = recv(ueventFd_, msg, UEVENT_MSG_LEN, 0);
59.     if (len < 0 || len >= UEVENT_MSG_LEN) {
60.         BATTERY_HILOGI(COMP_HDI, "recv return msg is invalid, len: %{public}zd", len);
61.         return;
62.     }
64.     // msg separator
65.     msg[len] = '\0';
66.     msg[len + 1] = '\0';
67.     std::string powerUevent;
68.     if (!MatchPowerUevent(msg, powerUevent)) {
69.         return;
70.     }
71.     BATTERY_HILOGD(FEATURE_BATT_INFO, "PowerUevent msg:%{public}s", powerUevent.c_str());
72.     UpdateBatteryInfo(service, powerUevent);
73. }
75. //更新电池信息
76. void BatteryThread::UpdateBatteryInfo(void* service, const std::string& powerUevent)
77. {
78.     BatteryInfo event = {};
79.     std::unique_ptr<BatterydInfo> batteryInfo = std::make_unique<BatterydInfo>();
80.     if (batteryInfo == nullptr) {
81.         BATTERY_HILOGE(FEATURE_BATT_INFO, "make_unique BatterydInfo error");
82.         return;
83.     }
84.     // 从系统文件中读取信息到batteryInfo
85.     provider_->UpdateInfoByReadSysFile(batteryInfo.get());
86.     //将batteryInfo 赋值event
87.     event.capacity = batteryInfo->capacity_;
88.     event.voltage= batteryInfo->voltage_;
89.     event.temperature = batteryInfo->temperature_;
90.     event.healthState = batteryInfo->healthState_;
91.     event.pluggedType = batteryInfo->pluggedType_;
92.     event.pluggedMaxCurrent = batteryInfo->pluggedMaxCurrent_;
93.     event.pluggedMaxVoltage = batteryInfo->pluggedMaxVoltage_;
94.     event.chargeState = batteryInfo->chargeState_;
95.     event.chargeCounter = batteryInfo->chargeCounter_;
96.     event.present = batteryInfo->present_;
97.     event.technology = batteryInfo->technology_;
98.     event.curNow = batteryInfo->curNow_;
99.     event.remainEnergy = batteryInfo->remainEnergy_;
100.     event.totalEnergy = batteryInfo->totalEnergy_;
101.     event.uevent = powerUevent;
103.     if (g_callback != nullptr) {
104.         g_callback->Update(event);   // 向注册的 Callback or Subscriber发送电池状态变更消息
105.     } else {
106.         BATTERY_HILOGI(FEATURE_BATT_INFO, "g_callback is nullptr");
107.     }
108. }

复制代码

  framework service端接口：

1. powermgr_battery_manager\services\native\src\battery_service.cpp
2. bool BatteryService::RegisterBatteryHdiCallback()
3. {
4.     std::lock_guard<std::shared_mutex> lock(mutex_);
5.     if (iBatteryInterface_ == nullptr) {
6.         iBatteryInterface_ = V2_0::IBatteryInterface::Get();
7.         BATTERY_HILOGE(COMP_SVC, "failed to get battery hdi interface");
8.         RETURN_IF_WITH_RET(iBatteryInterface_ == nullptr, false);
9.     }
10.     // 向BatteryInterface 注册一个 BatteryCallback，
11.     sptr<V2_0::IBatteryCallback> callback = new BatteryCallback();
12.     ErrCode ret = iBatteryInterface_->Register(callback);
13.     if (ret < 0) {
14.         BATTERY_HILOGE(COMP_SVC, "register callback failed");
15.         return false;
16.     }
17.      // 调用 BatteryCallback::RegisterBatteryEvent 更新回调处理函数（static）为HandleBatteryCallbackEvent
18.     BatteryCallback::BatteryEventCallback eventCb =
19.         std::bind(&BatteryService::HandleBatteryCallbackEvent, this, std::placeholders::_1);
20.     BatteryCallback::RegisterBatteryEvent(eventCb);
21.     return true;
22. }
25. int32_t BatteryService::HandleBatteryCallbackEvent(const V2_0::BatteryInfo& event)
26. {
27.     if (isMockUnplugged_ || isMockCapacity_) {
28.         return ERR_OK;
29.     }
31.     ConvertingEvent(event);
32.     RETURN_IF_WITH_RET(lastBatteryInfo_ == batteryInfo_, ERR_OK);
33.     HandleBatteryInfo();
34.     return ERR_OK;
35. }
37. //根据event事件，更新batteryInfo_
38. void BatteryService::ConvertingEvent(const V1_2::BatteryInfo& event)
39. {
40.     if (!isMockCapacity_) {
41.         batteryInfo_.SetCapacity(event.capacity);
42.     }
43.     if (!isMockUnplugged_) {
44.         batteryInfo_.SetPluggedType(BatteryPluggedType(event.pluggedType));
45.         batteryInfo_.SetPluggedMaxCurrent(event.pluggedMaxCurrent);
46.         batteryInfo_.SetPluggedMaxVoltage(event.pluggedMaxVoltage);
47.         batteryInfo_.SetChargeState(BatteryChargeState(event.chargeState));
48.     }
49.     batteryInfo_.SetVoltage(event.voltage);
50.     batteryInfo_.SetTemperature(event.temperature);
51.     batteryInfo_.SetHealthState(BatteryHealthState(event.healthState));
52.     batteryInfo_.SetChargeCounter(event.chargeCounter);
53.     batteryInfo_.SetTotalEnergy(event.totalEnergy);
54.     batteryInfo_.SetCurAverage(event.curAverage);
55.     batteryInfo_.SetRemainEnergy(event.remainEnergy);
56.     batteryInfo_.SetPresent(event.present);
57.     batteryInfo_.SetTechnology(event.technology);
58.     batteryInfo_.SetNowCurrent(event.curNow);
59.     batteryInfo_.SetChargeType(GetChargeType());
60. }
62. void BatteryService::HandleBatteryInfo()
63. {
64.     batteryLight_.UpdateColor(batteryInfo_.GetChargeState(), batteryInfo_.GetCapacity());
65.     // 若有外接电源插入/拔出，则唤醒设备
66.     WakeupDevice(batteryInfo_.GetPluggedType());
67.      // 根据batteryInfo_，更新
68.     CalculateRemainingChargeTime(batteryInfo_.GetCapacity(), batteryInfo_.GetChargeState());
69.     // BatteryNotify 发布电池信息更新事件
70.     batteryNotify_->PublishEvents(batteryInfo_);
71.     //其他信息更新
72.     HandleTemperature(batteryInfo_.GetTemperature());
73.     HandleCapacity(batteryInfo_.GetCapacity(), batteryInfo_.GetChargeState());
74.     lastBatteryInfo_ = batteryInfo_;
75. }

复制代码

2.电量品级定制开发
 &加粗样式ensp;OpenHarmony默认提供了电量品级，根据当前的电量来界说系齐备一的电量品级，如满电量、高电量、低电量、极低电量等。体系可以根据当前的电量品级对用户进行提示或处理相关业务。但是电量品级对应的电量值在不同的产品上规格是不同的，产品希望根据产品的设计规格来定制此特性。为此OpenHarmony提供了电量品级的定制方式，产品定制开发者可根据设计规格来定制此特性。battery_config.cpp（drivers_peripheral\battery\interfaces\hdi_service\src\）剖析配置文件battery_config.json。

1. drivers/peripheral/battery/interfaces/hdi_service/profile/battery_config.json:
2. 1 {
3. 2     "light": {
4. 3         "low": {
5. 4             "soc": [0, 10],
6. 5             "rgb": [255, 0, 0]
7. 6         },
8. 7         "normal": {
9. 8             "soc": [10, 90],
10. 9             "rgb": [255, 255, 0]
11. 10         },
12. 11         "high": {
13. 12             "soc": [90, 100],
14. 13             "rgb": [0, 255, 0]
15. 14         }
16. 15     },
17. 16     "boot_actions": {
18. 17         "sendcommonevent": [{
19. 18             "event_name": "usual.event.BATTERY_CHANGED",
20. 19             "scene_config": {
21. 20                 "name" : "wireless",
22. 21                 "not_equal" : "0"
23. 22             },
24. 23             "uevent": "battery common event"
25. 24         }]
26. 25     },
27. 26     "temperature": {
28. 27         "high": 680,
29. 28         "low": -500
30. 29     },
31. 30     "soc": {
32. 31         "shutdown": 5,
33. 32         "critical": 10,
34. 33         "warning": 15,
35. 34         "low": 30,
36. 35         "normal": 60,
37. 36         "high": 90,
38. 37         "full": 100
39. 38     },
40. 39     "charger": {
41. 40         "current_limit":{
42. 41             "path": "/data/service/el0/battery/current_limit"
43. 42         },
44. 43         "voltage_limit":{
45. 44             "path": "/data/service/el0/battery/voltage_limit"
46. 45         },
47. 46         "type": {
48. 47             "path": "/data/service/el0/battery/charger_type"
49. 48         }
50. 49     }
51. 50 }

复制代码

  电量品级配置说明:

refer to

• https://gitee.com/openharmony/powermgr_battery_manager
  
• https://gitee.com/openharmony/ace_napi/tree/master
  
• https://forums.openharmony.cn/forum.php?mod=viewthread&tid=616
  
• http://test.openharmony.cn:7780/pages/v4.1/zh-cn/device-dev/subsystems/subsys-power-battery-level-customization.md
  

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