1 /*
2 * Copyright (c) 2021 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 "lnn_event_monitor_impl.h"
17
18 #include "common_event_manager.h"
19 #include "common_event_support.h"
20 #include "lnn_async_callback_utils.h"
21 #include "lnn_log.h"
22 #include "wifi_msg.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_error_code.h"
25 #include "wifi_ap_msg.h"
26 #include "softbus_wifi_api_adapter.h"
27
28 static const int32_t DELAY_LEN = 1000;
29 static const int32_t RETRY_MAX = 20;
30 static const char *COMMON_EVENT_WIFI_SEMI_STATE = "usual.event.wifi.SEMI_STATE";
31 static const int32_t WIFI_UID = 1010;
32
33 namespace OHOS {
34 namespace EventFwk {
35 class WifiServiceMonitor : public CommonEventSubscriber {
36 public:
37 explicit WifiServiceMonitor(const CommonEventSubscribeInfo &subscriberInfo);
~WifiServiceMonitor()38 virtual ~WifiServiceMonitor() {}
39 virtual void OnReceiveEvent(const CommonEventData &data);
40 };
41
WifiServiceMonitor(const CommonEventSubscribeInfo & subscriberInfo)42 WifiServiceMonitor::WifiServiceMonitor(const CommonEventSubscribeInfo &subscriberInfo)
43 :CommonEventSubscriber(subscriberInfo)
44 {
45 }
46
SetSoftBusWifiConnState(const int code,SoftBusWifiState * state)47 static void SetSoftBusWifiConnState(const int code, SoftBusWifiState *state)
48 {
49 switch (code) {
50 case int(OHOS::Wifi::ConnState::OBTAINING_IPADDR):
51 *state = SOFTBUS_WIFI_OBTAINING_IPADDR;
52 break;
53 case int(OHOS::Wifi::ConnState::CONNECTED):
54 *state = SOFTBUS_WIFI_CONNECTED;
55 break;
56 case int(OHOS::Wifi::ConnState::DISCONNECTED):
57 *state = SOFTBUS_WIFI_DISCONNECTED;
58 break;
59 default: {
60 break;
61 }
62 }
63 }
64
SetSoftBusWifiUseState(const int code,SoftBusWifiState * state)65 static void SetSoftBusWifiUseState(const int code, SoftBusWifiState *state)
66 {
67 switch (code) {
68 case int(OHOS::Wifi::WifiState::DISABLED):
69 *state = SOFTBUS_WIFI_DISABLED;
70 break;
71 case int(OHOS::Wifi::WifiState::ENABLED):
72 *state = SOFTBUS_WIFI_ENABLED;
73 break;
74 default: {
75 break;
76 }
77 }
78 }
79
SetSoftBusWifiHotSpotState(const int code,SoftBusWifiState * state)80 static void SetSoftBusWifiHotSpotState(const int code, SoftBusWifiState *state)
81 {
82 switch (code) {
83 case int(OHOS::Wifi::ApState::AP_STATE_STARTED):
84 *state = SOFTBUS_AP_ENABLED;
85 break;
86 case int(OHOS::Wifi::ApState::AP_STATE_CLOSED):
87 *state = SOFTBUS_AP_DISABLED;
88 break;
89 default: {
90 break;
91 }
92 }
93 }
94
SetSoftBusWifiSemiState(const int code,SoftBusWifiState * state)95 static void SetSoftBusWifiSemiState(const int code, SoftBusWifiState *state)
96 {
97 switch (code) {
98 case int(OHOS::Wifi::WifiDetailState::STATE_SEMI_ACTIVE):
99 *state = SOFTBUS_WIFI_SEMI_ACTIVE;
100 break;
101 default: {
102 break;
103 }
104 }
105 }
106
OnReceiveEvent(const CommonEventData & data)107 void WifiServiceMonitor::OnReceiveEvent(const CommonEventData &data)
108 {
109 int code = data.GetCode();
110 std::string action = data.GetWant().GetAction();
111 SoftBusWifiState state = SOFTBUS_WIFI_UNKNOWN;
112 LNN_LOGI(LNN_BUILDER, "notify wifiservice event=%{public}s, code=%{public}d", action.c_str(), code);
113 if (action == CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE) {
114 SetSoftBusWifiConnState(code, &state);
115 }
116 if (action == CommonEventSupport::COMMON_EVENT_WIFI_POWER_STATE) {
117 SetSoftBusWifiUseState(code, &state);
118 }
119 if (action == CommonEventSupport::COMMON_EVENT_WIFI_HOTSPOT_STATE) {
120 SetSoftBusWifiHotSpotState(code, &state);
121 }
122 if (action.compare(COMMON_EVENT_WIFI_SEMI_STATE) == 0) {
123 SetSoftBusWifiSemiState(code, &state);
124 }
125 if (state != SOFTBUS_WIFI_UNKNOWN) {
126 SoftBusWifiState *notifyState = (SoftBusWifiState *)SoftBusMalloc(sizeof(SoftBusWifiState));
127 if (notifyState == NULL) {
128 LNN_LOGE(LNN_BUILDER, "notifyState malloc err");
129 return;
130 }
131 *notifyState = state;
132 int32_t ret = LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), LnnNotifyWlanStateChangeEvent,
133 (void *)notifyState);
134 if (ret != SOFTBUS_OK) {
135 LNN_LOGE(LNN_BUILDER, "async notify wifi state err, ret=%{public}d", ret);
136 SoftBusFree(notifyState);
137 }
138 }
139 }
140
141 class SubscribeEvent {
142 public:
143 int32_t SubscribeWifiConnStateEvent();
144 int32_t SubscribeWifiPowerStateEvent();
145 int32_t SubscribeAPConnStateEvent();
146 int32_t SubscribeWifiSemiStateEvent();
147 };
148
SubscribeAPConnStateEvent()149 int32_t SubscribeEvent::SubscribeAPConnStateEvent()
150 {
151 MatchingSkills matchingSkills;
152 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_WIFI_HOTSPOT_STATE);
153 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
154 std::shared_ptr<WifiServiceMonitor> subscriberPtr = std::make_shared<WifiServiceMonitor>(subscriberInfo);
155 if (!CommonEventManager::SubscribeCommonEvent(subscriberPtr)) {
156 return SOFTBUS_NETWORK_SUBSCRIBE_COMMON_EVENT_FAILED;
157 }
158 return SOFTBUS_OK;
159 }
160
SubscribeWifiConnStateEvent()161 int32_t SubscribeEvent::SubscribeWifiConnStateEvent()
162 {
163 MatchingSkills matchingSkills;
164 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE);
165 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
166 std::shared_ptr<WifiServiceMonitor> subscriberPtr = std::make_shared<WifiServiceMonitor>(subscriberInfo);
167 if (!CommonEventManager::SubscribeCommonEvent(subscriberPtr)) {
168 return SOFTBUS_NETWORK_SUBSCRIBE_COMMON_EVENT_FAILED;
169 }
170 return SOFTBUS_OK;
171 }
172
SubscribeWifiPowerStateEvent()173 int32_t SubscribeEvent::SubscribeWifiPowerStateEvent()
174 {
175 MatchingSkills matchingSkills;
176 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_WIFI_POWER_STATE);
177 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
178 std::shared_ptr<WifiServiceMonitor> subscriberPtr = std::make_shared<WifiServiceMonitor>(subscriberInfo);
179 if (!CommonEventManager::SubscribeCommonEvent(subscriberPtr)) {
180 return SOFTBUS_NETWORK_SUBSCRIBE_COMMON_EVENT_FAILED;
181 }
182 return SOFTBUS_OK;
183 }
184
SubscribeWifiSemiStateEvent()185 int32_t SubscribeEvent::SubscribeWifiSemiStateEvent()
186 {
187 MatchingSkills matchingSkills;
188 matchingSkills.AddEvent(COMMON_EVENT_WIFI_SEMI_STATE);
189 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
190 subscriberInfo.SetPublisherUid(WIFI_UID);
191 std::shared_ptr<WifiServiceMonitor> subscriberPtr = std::make_shared<WifiServiceMonitor>(subscriberInfo);
192 if (!CommonEventManager::SubscribeCommonEvent(subscriberPtr)) {
193 return SOFTBUS_NETWORK_SUBSCRIBE_COMMON_EVENT_FAILED;
194 }
195 return SOFTBUS_OK;
196 }
197 } // namespace EventFwk
198 } // namespace OHOS
199
UpdateLocalWifiActiveCapability(void)200 static void UpdateLocalWifiActiveCapability(void)
201 {
202 SoftBusWifiState *notifyState = (SoftBusWifiState *)SoftBusMalloc(sizeof(SoftBusWifiState));
203 if (notifyState == NULL) {
204 LNN_LOGE(LNN_BUILDER, "notifyState malloc err");
205 return;
206 }
207 bool isWifiActive = SoftBusIsWifiActive();
208 if (!isWifiActive) {
209 *notifyState = SOFTBUS_WIFI_DISABLED;
210 } else {
211 *notifyState = SOFTBUS_WIFI_ENABLED;
212 }
213 int32_t ret = LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), LnnNotifyWlanStateChangeEvent,
214 (void *)notifyState);
215 if (ret != SOFTBUS_OK) {
216 LNN_LOGE(LNN_BUILDER, "async notify wifi state err, ret=%{public}d", ret);
217 SoftBusFree(notifyState);
218 }
219 }
220
UpdateLocalWifiConnCapability(void)221 static void UpdateLocalWifiConnCapability(void)
222 {
223 SoftBusWifiState *notifyState = (SoftBusWifiState *)SoftBusMalloc(sizeof(SoftBusWifiState));
224 if (notifyState == NULL) {
225 LNN_LOGE(LNN_BUILDER, "notifyState malloc err");
226 return;
227 }
228 SoftBusWifiLinkedInfo info;
229 (void)memset_s(&info, sizeof(SoftBusWifiLinkedInfo), 0, sizeof(SoftBusWifiLinkedInfo));
230 if (SoftBusGetLinkedInfo(&info) != SOFTBUS_OK) {
231 LNN_LOGE(LNN_BUILDER, "get link info failed");
232 SoftBusFree(notifyState);
233 return;
234 }
235 if (info.connState == SOFTBUS_API_WIFI_DISCONNECTED) {
236 *notifyState = SOFTBUS_WIFI_DISCONNECTED;
237 } else {
238 *notifyState = SOFTBUS_WIFI_CONNECTED;
239 }
240 int32_t ret = LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), LnnNotifyWlanStateChangeEvent,
241 (void *)notifyState);
242 if (ret != SOFTBUS_OK) {
243 LNN_LOGE(LNN_BUILDER, "async notify wifi state err, ret=%{public}d", ret);
244 SoftBusFree(notifyState);
245 }
246 }
247
LnnSubscribeWifiService(void * para)248 static void LnnSubscribeWifiService(void *para)
249 {
250 (void)para;
251 static int32_t retry = 0;
252 if (retry > RETRY_MAX) {
253 LNN_LOGE(LNN_BUILDER, "try subscribe wifiservice event max times");
254 return;
255 }
256 OHOS::EventFwk::SubscribeEvent *subscriberPtr = new OHOS::EventFwk::SubscribeEvent();
257 if (subscriberPtr == nullptr) {
258 LNN_LOGE(LNN_BUILDER, "SubscribeEvent init fail");
259 return;
260 }
261 if (subscriberPtr->SubscribeWifiConnStateEvent() == SOFTBUS_OK &&
262 subscriberPtr->SubscribeWifiPowerStateEvent() == SOFTBUS_OK &&
263 subscriberPtr->SubscribeAPConnStateEvent() == SOFTBUS_OK &&
264 subscriberPtr->SubscribeWifiSemiStateEvent() == SOFTBUS_OK) {
265 LNN_LOGI(LNN_BUILDER, "subscribe wifiservice conn and power state success");
266 UpdateLocalWifiActiveCapability();
267 UpdateLocalWifiConnCapability();
268 } else {
269 LNN_LOGE(LNN_BUILDER, "subscribe wifiservice event fail");
270 retry++;
271 SoftBusLooper *looper = GetLooper(LOOP_TYPE_DEFAULT);
272 if (LnnAsyncCallbackDelayHelper(looper, LnnSubscribeWifiService, NULL, DELAY_LEN) != SOFTBUS_OK) {
273 LNN_LOGE(LNN_BUILDER, "LnnAsyncCallbackDelayHelper fail");
274 }
275 }
276 delete subscriberPtr;
277 }
278
LnnInitWifiServiceMonitorImpl(void)279 int32_t LnnInitWifiServiceMonitorImpl(void)
280 {
281 SoftBusLooper *looper = GetLooper(LOOP_TYPE_DEFAULT);
282 int32_t ret = LnnAsyncCallbackDelayHelper(looper, LnnSubscribeWifiService, NULL, DELAY_LEN);
283 if (ret != SOFTBUS_OK) {
284 LNN_LOGE(LNN_INIT, "LnnAsyncCallbackDelayHelper fail");
285 }
286 return ret;
287 }
288