1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "event_publisher.h"
17 
18 #ifdef POWERMGR_BATTERY_MANAGER_ENABLE
19 #include "battery_srv_client.h"
20 #endif // POWERMGR_BATTERY_MANAGER_ENABLE
21 #include "common_event_manager.h"
22 #include "common_event_support.h"
23 #ifdef COMMUNICATION_NETMANAGER_BASE_ENABLE
24 #include "net_supplier_info.h"
25 #endif
26 #include "want.h"
27 #include "work_sched_hilog.h"
28 
29 namespace OHOS {
30 namespace WorkScheduler {
31 namespace {
32     static const std::string NETWORK = "network";
33     static const std::string EV_NETWORK_TYPE_WIFI = "wifi";
34     static const std::string EV_NETWORK_TYPE_DISCONNECT = "disconnect";
35     static const std::string CHARGING = "charging";
36     static const std::string EV_CHARGING_TYPE_USB = "usb";
37     static const std::string EV_CHARGING_TYPE_AC = "ac";
38     static const std::string EV_CHARGING_TYPE_WIRELESS = "wireless";
39     static const std::string EV_CHARGING_TYPE_NONE = "none";
40     static const std::string BATTERY_STATUS = "batteryStatus";
41     static const std::string STORAGE = "storage";
42     static const std::string EV_STORAGE_LOW = "low";
43     static const std::string EV_STORAGE_OKAY = "ok";
44 }
45 
Dump(std::string & result,std::string & eventType,std::string & eventValue)46 void EventPublisher::Dump(std::string &result, std::string &eventType, std::string &eventValue)
47 {
48     if (eventType == "event" && eventValue == "info") {
49         result.append("event info:\n")
50             .append("    network wifi: publish COMMON_EVENT_CONNECTIVITY_CHANGE event(wifi).\n")
51             .append("    network disconnect: publish COMMON_EVENT_CONNECTIVITY_CHANGE event(disconnect).\n")
52             .append("    charging usb: publish usb charging event\n")
53             .append("    charging ac: publish ac charging event\n")
54             .append("    charging wireless: publish wireless charging event\n")
55             .append("    charging none: publish unplugged event\n")
56             .append("    storage low: publish COMMON_EVENT_DEVICE_STORAGE_LOW event\n")
57             .append("    storage ok: publish COMMON_EVENT_DEVICE_STORAGE_OKAY event\n")
58             .append("    batteryStatus low: publish COMMON_EVENT_BATTERY_LOW\n")
59             .append("    batteryStatus ok: publish COMMON_EVENT_BATTERY_OKAY\n");
60     } else {
61         PublishEvent(result, eventType, eventValue);
62     }
63 }
64 
PublishEvent(std::string & result,std::string & eventType,std::string & eventValue)65 void EventPublisher::PublishEvent(std::string &result, std::string &eventType, std::string &eventValue)
66 {
67     if (eventType == NETWORK) {
68         PublishNetworkEvent(result, eventValue);
69     } else if (eventType == CHARGING) {
70         PublishChargingEvent(result, eventValue);
71     } else if (eventType == STORAGE) {
72         PublishStorageEvent(result, eventValue);
73     } else if (eventType == BATTERY_STATUS) {
74         PublishBatteryStatusEvent(result, eventValue);
75     } else {
76         result.append(std::string("dump -d need right params."));
77     }
78 }
79 
PublishNetworkEvent(std::string & result,std::string & eventValue)80 void EventPublisher::PublishNetworkEvent(std::string &result, std::string &eventValue)
81 {
82 #ifdef COMMUNICATION_NETMANAGER_BASE_ENABLE
83     EventFwk::Want want;
84     if (eventValue == EV_NETWORK_TYPE_WIFI) {
85         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
86         want.SetParam("NetType", 1);
87         result.append("publishing COMMON_EVENT_WIFI_CONN_STATE\n");
88         EventFwk::CommonEventData data;
89         data.SetWant(want);
90         data.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_CONNECTED);
91         bool isSuccess = EventFwk::CommonEventManager::PublishCommonEvent(data);
92         result.append("publish result: " + std::to_string(isSuccess));
93     } else if (eventValue == EV_NETWORK_TYPE_DISCONNECT) {
94         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
95         result.append("publishing COMMON_EVENT_WIFI_CONN_STATE\n");
96         EventFwk::CommonEventData data;
97         data.SetWant(want);
98         data.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_DISCONNECTED);
99         bool isSuccess = EventFwk::CommonEventManager::PublishCommonEvent(data);
100         result.append("publish result: " + std::to_string(isSuccess));
101     } else {
102         result.append("dump need right param.");
103         return;
104     }
105 #endif
106 }
107 
PublishChargingEvent(std::string & result,std::string & eventValue)108 void EventPublisher::PublishChargingEvent(std::string &result, std::string &eventValue)
109 {
110 #ifdef POWERMGR_BATTERY_MANAGER_ENABLE
111     EventFwk::Want want;
112     EventFwk::CommonEventData data;
113     if (eventValue == EV_CHARGING_TYPE_AC) {
114         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
115         data.SetWant(want);
116         data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC));
117     } else if (eventValue == EV_CHARGING_TYPE_USB) {
118         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
119         data.SetWant(want);
120         data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB));
121     } else if (eventValue == EV_CHARGING_TYPE_WIRELESS) {
122         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
123         data.SetWant(want);
124         data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_WIRELESS));
125     } else if (eventValue == EV_CHARGING_TYPE_NONE) {
126         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
127         data.SetWant(want);
128         data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE));
129     } else {
130         result.append("dump need right param.");
131         return;
132     }
133     EventFwk::CommonEventPublishInfo publishInfo;
134     publishInfo.SetOrdered(false);
135     if (EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo)) {
136         result.append("publish charging event ret: true");
137     } else {
138         result.append("publish charging event ret: false");
139     }
140 #endif // POWERMGR_BATTERY_MANAGER_ENABLE
141 }
142 
PublishStorageEvent(std::string & result,std::string & eventValue)143 void EventPublisher::PublishStorageEvent(std::string &result, std::string &eventValue)
144 {
145     EventFwk::Want want;
146     if (eventValue == EV_STORAGE_LOW) {
147         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DEVICE_STORAGE_LOW);
148         result.append("publishing COMMON_EVENT_DEVICE_STORAGE_LOW\n");
149     } else if (eventValue == EV_STORAGE_OKAY) {
150         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DEVICE_STORAGE_OK);
151         result.append("publishing COMMON_EVENT_DEVICE_STORAGE_OKAY\n");
152     } else {
153         result.append("dump need right param.");
154         return;
155     }
156     EventFwk::CommonEventData data;
157     data.SetWant(want);
158     bool isSuccess = EventFwk::CommonEventManager::PublishCommonEvent(data);
159     result.append("publish result: " + std::to_string(isSuccess));
160 }
161 
PublishBatteryStatusEvent(std::string & result,std::string & eventValue)162 void EventPublisher::PublishBatteryStatusEvent(std::string &result, std::string &eventValue)
163 {
164     EventFwk::Want want;
165     if (eventValue == EV_STORAGE_LOW) {
166         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
167         result.append("publishing COMMON_EVENT_BATTERY_LOW\n");
168         EventFwk::CommonEventData data;
169         data.SetWant(want);
170         const int32_t lowCapacity = 0;
171         data.SetCode(lowCapacity);
172         bool isSuccess = EventFwk::CommonEventManager::PublishCommonEvent(data);
173         result.append("publish result: " + std::to_string(isSuccess));
174     } else if (eventValue == EV_STORAGE_OKAY) {
175         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_OKAY);
176         result.append("publishing COMMON_EVENT_BATTERY_OKAY\n");
177         EventFwk::CommonEventData data;
178         data.SetWant(want);
179         const int32_t fullCapacity = 100;
180         data.SetCode(fullCapacity);
181         bool isSuccess = EventFwk::CommonEventManager::PublishCommonEvent(data);
182         result.append("publish result: " + std::to_string(isSuccess));
183     } else {
184         result.append("dump need right param.");
185         return;
186     }
187 }
188 } // namespace WorkScheduler
189 } // namespace OHOS