1 /*
2  * Copyright (c) 2022-2024 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 #ifdef RESSCHED_RESOURCESCHEDULE_SOC_PERF_ENABLE
17 #include "socperf_plugin.h"
18 #include "app_mgr_constants.h"
19 #include "config_info.h"
20 #include "dlfcn.h"
21 #include "fcntl.h"
22 #include "plugin_mgr.h"
23 #include "res_type.h"
24 #include "socperf_log.h"
25 
26 namespace OHOS {
27 namespace ResourceSchedule {
28 using namespace ResType;
29 namespace {
30     const std::string LIB_NAME = "libsocperf_plugin.z.so";
31     const std::string PLUGIN_NAME = "SOCPERF";
32     const std::string CONFIG_NAME_SOCPERF_FEATURE_SWITCH = "socperfFeatureSwitch";
33     const std::string CONFIG_NAME_SOCPERF_EVENT_ID = "socperfEventId";
34     const std::string SUB_ITEM_KEY_NAME_SOCPERF_ON_DEMAND = "socperf_on_demand";
35     const std::string CNOFIG_NAME_SOCPERF_CRUCIAL_FUNC = "socperfCrucialFunc";
36     const std::string SUB_ITEM_KEY_NAME_SOCPERF_RERQ_APPTYPE_PATH = "socperf_req_apptype_path";
37     const std::string SUB_ITEM_KEY_NAME_SOCPERF_RERQ_APPTYPE_FUNC = "socperf_req_apptype_func";
38     const std::string BUNDLE_NAME = "bundleName";
39     const std::string SOCPERF_TYPE_ID = "socperf_type_id";
40     const std::string SOCPERF_TYPE_RGM = "socperf_type_rgm";
41     const std::string EXTENSION_TYPE_KEY = "extensionType";
42     const std::string DEVICE_MODE_PAYMODE_NAME = "deviceMode";
43     const int32_t INVALID_VALUE                             = -1;
44     const int32_t APP_TYPE_GAME                             = 2;
45     const int32_t POWERMODE_ON                              = 601;
46     const int64_t TIME_INTERVAL                             = 5000;
47     const int32_t PERF_REQUEST_CMD_ID_RGM_BOOTING_START     = 1000;
48     const int32_t PERF_REQUEST_CMD_ID_POWERMODE_CHANGED     = 9000;
49     const int32_t PERF_REQUEST_CMD_ID_APP_START             = 10000;
50     const int32_t PERF_REQUEST_CMD_ID_WARM_START            = 10001;
51     const int32_t PERF_REQUEST_CMD_ID_WINDOW_SWITCH         = 10002;
52     const int32_t PERF_REQUEST_CMD_ID_EVENT_CLICK           = 10006;
53     const int32_t PERF_REQUEST_CMD_ID_LOAD_PAGE_START       = 10007;
54     const int32_t PERF_REQUEST_CMD_ID_EVENT_SLIDE           = 10008;
55     const int32_t PERF_REQUEST_CMD_ID_EVENT_SLIDE_OVER      = 10009;
56     const int32_t PERF_REQUEST_CMD_ID_EVENT_TOUCH_DOWN      = 10010;
57     const int32_t PERF_REQUEST_CMD_ID_LOAD_PAGE_COMPLETE    = 10011;
58     const int32_t PERF_REQUEST_CMD_ID_EVENT_WEB_GESTURE     = 10012;
59     const int32_t PERF_REQUEST_CMD_ID_POP_PAGE              = 10016;
60     const int32_t PERF_REQUEST_CMD_ID_RESIZE_WINDOW         = 10018;
61     const int32_t PERF_REQUEST_CMD_ID_MOVE_WINDOW           = 10019;
62     const int32_t PERF_REQUEST_CMD_ID_WEB_GESTURE_MOVE      = 10020;
63     const int32_t PERF_REQUEST_CMD_ID_WEB_SLIDE_NORMAL      = 10025;
64     const int32_t PERF_REQUEST_CMD_ID_ROTATION              = 10027;
65     const int32_t PERF_REQUEST_CMD_ID_REMOTE_ANIMATION      = 10030;
66     const int32_t PERF_REQUEST_CMD_ID_DRAG_STATUS_BAR       = 10034;
67     const int32_t PERF_REQUEST_CMD_ID_GAME_START            = 10036;
68     const int32_t PERF_REQUEST_CMD_ID_EVENT_TOUCH_UP        = 10040;
69     const int32_t PERF_REQUEST_CMD_ID_REMOTE_UNLOCK         = 10041;
70     const int32_t PERF_REQUEST_CMD_ID_ACCOUNT_ACTIVATING    = 10043;
71     const int32_t PERF_REQUEST_CMD_ID_LOAD_URL              = 10070;
72     const int32_t PERF_REQUEST_CMD_ID_MOUSEWHEEL            = 10071;
73     const int32_t PERF_REQUEST_CMD_ID_WEB_DRAG_RESIZE       = 10073;
74     const int32_t PERF_REQUEST_CMD_ID_BMM_MONITER_START     = 10081;
75 }
76 IMPLEMENT_SINGLE_INSTANCE(SocPerfPlugin)
77 
Init()78 void SocPerfPlugin::Init()
79 {
80     InitEventId();
81     InitResTypes();
82     InitFunctionMap();
83     for (auto resType : resTypes) {
84         PluginMgr::GetInstance().SubscribeResource(LIB_NAME, resType);
85     }
86     InitPerfCrucialSo();
87     SOC_PERF_LOGI("SocPerfPlugin::Init success");
88 }
89 
InitPerfCrucialSo()90 void SocPerfPlugin::InitPerfCrucialSo()
91 {
92     PluginConfig itemLists = PluginMgr::GetInstance().GetConfig(PLUGIN_NAME, CNOFIG_NAME_SOCPERF_CRUCIAL_FUNC);
93     for (const Item& item : itemLists.itemList) {
94         for (SubItem sub : item.subItemList) {
95             if (sub.name == SUB_ITEM_KEY_NAME_SOCPERF_RERQ_APPTYPE_PATH) {
96                 perfReqAppTypeSoPath_ = sub.value;
97             }
98             if (sub.name == SUB_ITEM_KEY_NAME_SOCPERF_RERQ_APPTYPE_FUNC) {
99                 perfReqAppTypeSoFunc_ = sub.value;
100             }
101         }
102     }
103 
104     if (!perfReqAppTypeSoPath_.empty() && !perfReqAppTypeSoFunc_.empty()) {
105         InitPerfCrucialFunc(perfReqAppTypeSoPath_.c_str(), perfReqAppTypeSoFunc_.c_str());
106     }
107 }
108 
InitPerfCrucialFunc(const char* perfSoPath, const char* perfSoFunc)109 void SocPerfPlugin::InitPerfCrucialFunc(const char* perfSoPath, const char* perfSoFunc)
110 {
111     if (!perfSoPath || !perfSoFunc) {
112         return;
113     }
114     handle_ = dlopen(perfSoPath, RTLD_NOW);
115     if (!handle_) {
116         SOC_PERF_LOGE("perf so doesn't exist");
117         return;
118     }
119 
120     reqAppTypeFunc_ = reinterpret_cast<ReqAppTypeFunc>(dlsym(handle_, perfSoFunc));
121     if (!reqAppTypeFunc_) {
122         SOC_PERF_LOGE("perf func req app type doesn't exist");
123         dlclose(handle_);
124         handle_ = nullptr;
125     }
126 }
127 
InitEventId()128 void SocPerfPlugin::InitEventId()
129 {
130     PluginConfig itemLists = PluginMgr::GetInstance().GetConfig(PLUGIN_NAME, CONFIG_NAME_SOCPERF_EVENT_ID);
131     for (const Item& item : itemLists.itemList) {
132         for (SubItem sub : item.subItemList) {
133             if (sub.name == SOCPERF_TYPE_ID) {
134                 RES_TYPE_SCENE_BOARD_ID = atoi(sub.value.c_str());
135             } else if (sub.name == SOCPERF_TYPE_RGM) {
136                 RES_TYPE_RGM_BOOTING_STATUS = atoi(sub.value.c_str());
137             }
138         }
139     }
140 }
141 
InitFunctionMap()142 void SocPerfPlugin::InitFunctionMap()
143 {
144     functionMap = {
145         { RES_TYPE_WINDOW_FOCUS,
146             [this](const std::shared_ptr<ResData>& data) { HandleWindowFocus(data); } },
147         { RES_TYPE_CLICK_RECOGNIZE,
148             [this](const std::shared_ptr<ResData>& data) { HandleEventClick(data); } },
149         { RES_TYPE_LOAD_PAGE,
150             [this](const std::shared_ptr<ResData>& data) { HandleLoadPage(data); } },
151         { RES_TYPE_SLIDE_RECOGNIZE,
152             [this](const std::shared_ptr<ResData>& data) { HandleEventSlide(data); } },
153         { RES_TYPE_WEB_GESTURE,
154             [this](const std::shared_ptr<ResData>& data) { HandleEventWebGesture(data); } },
155         { RES_TYPE_POP_PAGE,
156             [this](const std::shared_ptr<ResData>& data) { HandlePopPage(data); } },
157         { RES_TYPE_APP_ABILITY_START,
158             [this](const std::shared_ptr<ResData>& data) { HandleAppAbilityStart(data); } },
159         { RES_TYPE_RESIZE_WINDOW,
160             [this](const std::shared_ptr<ResData>& data) { HandleResizeWindow(data); } },
161         { RES_TYPE_MOVE_WINDOW,
162             [this](const std::shared_ptr<ResData>& data) { HandleMoveWindow(data); } },
163         { RES_TYPE_SHOW_REMOTE_ANIMATION,
164             [this](const std::shared_ptr<ResData>& data) { HandleRemoteAnimation(data); } },
165         { RES_TYPE_DRAG_STATUS_BAR,
166             [this](const std::shared_ptr<ResData>& data) { HandleDragStatusBar(data); } },
167         { RES_TYPE_WEB_GESTURE_MOVE,
168             [this](const std::shared_ptr<ResData>& data) { HandleWebGestureMove(data); } },
169         { RES_TYPE_WEB_SLIDE_NORMAL,
170             [this](const std::shared_ptr<ResData>& data) { HandleWebSlideNormal(data); } },
171         { RES_TYPE_LOAD_URL,
172             [this](const std::shared_ptr<ResData>& data) { HandleLoadUrl(data); } },
173         { RES_TYPE_MOUSEWHEEL,
174             [this](const std::shared_ptr<ResData>& data) { HandleMousewheel(data); } },
175         { RES_TYPE_APP_STATE_CHANGE,
176             [this](const std::shared_ptr<ResData>& data) { HandleAppStateChange(data); } },
177         { RES_TYPE_DEVICE_MODE_STATUS,
178             [this](const std::shared_ptr<ResData>& data) { HandleDeviceModeStatusChange(data); } },
179         { RES_TYPE_WEB_DRAG_RESIZE,
180             [this](const std::shared_ptr<ResData>& data) { HandleWebDragResize(data); } },
181         { RES_TYPE_ACCOUNT_ACTIVATING,
182             [this](const std::shared_ptr<ResData>& data) { HandleSocperfAccountActivating(data); } },
183         { RES_TYPE_ANCO_CUST,
184             [this](const std::shared_ptr<ResData>& data) { HandleCustEvent(data); } },
185         { RES_TYPE_SOCPERF_CUST_EVENT_BEGIN,
186             [this](const std::shared_ptr<ResData>& data) { HandleCustEventBegin(data); } },
187         { RES_TYPE_SOCPERF_CUST_EVENT_END,
188             [this](const std::shared_ptr<ResData>& data) { HandleCustEventEnd(data); } },
189     };
190     AddEventToFunctionMap();
191 }
192 
AddEventToFunctionMap()193 void SocPerfPlugin::AddEventToFunctionMap()
194 {
195     functionMap.insert(std::make_pair(RES_TYPE_ONLY_PERF_APP_COLD_START,
196         [this](const std::shared_ptr<ResData>& data) { HandleAppColdStartEx(data); }));
197     functionMap.insert(std::make_pair(RES_TYPE_SCENE_ROTATION,
198         [this](const std::shared_ptr<ResData>& data) { HandleSceneRotation(data); }));
199     functionMap.insert(std::make_pair(RES_TYPE_BMM_MONITER_CHANGE_EVENT,
200         [this](const std::shared_ptr<ResData>& data) { HandleBmmMoniterStatus(data); }));
201     functionMap.insert(std::make_pair(RES_TYPE_POWER_MODE_CHANGED,
202         [this](const std::shared_ptr<ResData>& data) { HandlePowerModeChanged(data); }));
203     if (RES_TYPE_SCENE_BOARD_ID != 0) {
204         functionMap.insert(std::make_pair(RES_TYPE_SCENE_BOARD_ID,
205             [this](const std::shared_ptr<ResData>& data) { HandleSocperfSceneBoard(data); }));
206     }
207     if (RES_TYPE_RGM_BOOTING_STATUS != 0) {
208         functionMap.insert(std::make_pair(RES_TYPE_RGM_BOOTING_STATUS,
209             [this](const std::shared_ptr<ResData>& data) { HandleRgmBootingStatus(data); }));
210     }
211 }
212 
InitResTypes()213 void SocPerfPlugin::InitResTypes()
214 {
215     resTypes = {
216         RES_TYPE_WINDOW_FOCUS,
217         RES_TYPE_CLICK_RECOGNIZE,
218         RES_TYPE_LOAD_PAGE,
219         RES_TYPE_SLIDE_RECOGNIZE,
220         RES_TYPE_WEB_GESTURE,
221         RES_TYPE_POP_PAGE,
222         RES_TYPE_APP_ABILITY_START,
223         RES_TYPE_RESIZE_WINDOW,
224         RES_TYPE_MOVE_WINDOW,
225         RES_TYPE_SHOW_REMOTE_ANIMATION,
226         RES_TYPE_DRAG_STATUS_BAR,
227         RES_TYPE_WEB_GESTURE_MOVE,
228         RES_TYPE_WEB_SLIDE_NORMAL,
229         RES_TYPE_LOAD_URL,
230         RES_TYPE_MOUSEWHEEL,
231         RES_TYPE_APP_STATE_CHANGE,
232         RES_TYPE_DEVICE_MODE_STATUS,
233         RES_TYPE_WEB_DRAG_RESIZE,
234         RES_TYPE_ACCOUNT_ACTIVATING,
235         RES_TYPE_ANCO_CUST,
236         RES_TYPE_SOCPERF_CUST_EVENT_BEGIN,
237         RES_TYPE_SOCPERF_CUST_EVENT_END,
238         RES_TYPE_ONLY_PERF_APP_COLD_START,
239         RES_TYPE_SCENE_ROTATION,
240         RES_TYPE_BMM_MONITER_CHANGE_EVENT,
241         RES_TYPE_POWER_MODE_CHANGED,
242     };
243     if (RES_TYPE_SCENE_BOARD_ID != 0) {
244         resTypes.insert(RES_TYPE_SCENE_BOARD_ID);
245     }
246     if (RES_TYPE_RGM_BOOTING_STATUS != 0) {
247         resTypes.insert(RES_TYPE_RGM_BOOTING_STATUS);
248     }
249 }
250 
Disable()251 void SocPerfPlugin::Disable()
252 {
253     functionMap.clear();
254     for (auto resType : resTypes) {
255         PluginMgr::GetInstance().UnSubscribeResource(LIB_NAME, resType);
256     }
257     resTypes.clear();
258     if (handle_ != nullptr) {
259         dlclose(handle_);
260         handle_ = nullptr;
261     }
262     SOC_PERF_LOGI("SocPerfPlugin::Disable success");
263 }
264 
DispatchResource(const std::shared_ptr<ResData>& data)265 void SocPerfPlugin::DispatchResource(const std::shared_ptr<ResData>& data)
266 {
267     auto funcIter = functionMap.find(data->resType);
268     if (funcIter != functionMap.end()) {
269         auto function = funcIter->second;
270         if (function) {
271             function(data);
272         }
273     }
274 }
275 
InitFeatureSwitch(std::string featureName)276 bool SocPerfPlugin::InitFeatureSwitch(std::string featureName)
277 {
278     PluginConfig itemLists = PluginMgr::GetInstance().GetConfig(PLUGIN_NAME, CONFIG_NAME_SOCPERF_FEATURE_SWITCH);
279     for (const Item& item : itemLists.itemList) {
280         for (SubItem sub : item.subItemList) {
281             if (sub.name == featureName) {
282                 return sub.value == "1";
283             }
284         }
285     }
286     return false;
287 }
288 
ParsePayload(const std::shared_ptr<ResData>& data, const std::string& key)289 static int32_t ParsePayload(const std::shared_ptr<ResData>& data, const std::string& key)
290 {
291     if (!data->payload.contains(key)) {
292         return INVALID_VALUE;
293     }
294     if (data->payload.at(key).is_string()) {
295         return atoi(data->payload[key].get<std::string>().c_str());
296     }
297     if (data->payload.at(key).is_number_integer()) {
298         return data->payload[key].get<int32_t>();
299     }
300     return INVALID_VALUE;
301 }
302 
HandleAppAbilityStart(const std::shared_ptr<ResData>& data)303 void SocPerfPlugin::HandleAppAbilityStart(const std::shared_ptr<ResData>& data)
304 {
305     if (data->value == AppStartType::APP_COLD_START) {
306         SOC_PERF_LOGI("SocPerfPlugin: socperf->APP_COLD_START");
307         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_APP_START, "");
308         int32_t appType = INVALID_VALUE;
309         if (reqAppTypeFunc_ != nullptr && data->payload != nullptr && data->payload.contains(BUNDLE_NAME)) {
310             std::string bundleName = data->payload[BUNDLE_NAME].get<std::string>().c_str();
311             appType = reqAppTypeFunc_(bundleName);
312         }
313         if (appType == APP_TYPE_GAME) {
314             SOC_PERF_LOGI("SocPerfPlugin: socperf->Game cold start");
315             OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_GAME_START, "");
316         }
317     } else if (data->value == AppStartType::APP_WARM_START) {
318         SOC_PERF_LOGI("SocPerfPlugin: socperf->APP_WARM_START");
319         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_WARM_START, "");
320     }
321 }
322 
HandleWindowFocus(const std::shared_ptr<ResData>& data)323 void SocPerfPlugin::HandleWindowFocus(const std::shared_ptr<ResData>& data)
324 {
325     if (data->value == WindowFocusStatus::WINDOW_FOCUS) {
326         SOC_PERF_LOGI("SocPerfPlugin: socperf->WINDOW_SWITCH");
327         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_WINDOW_SWITCH, "");
328     }
329 }
330 
HandleEventClick(const std::shared_ptr<ResData>& data)331 void SocPerfPlugin::HandleEventClick(const std::shared_ptr<ResData>& data)
332 {
333     SOC_PERF_LOGD("SocPerfPlugin: socperf->EVENT_CLICK: %{public}lld", (long long)data->value);
334     // touch down event
335     if (data->value == ClickEventType::TOUCH_EVENT_DOWN) {
336         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_EVENT_TOUCH_DOWN, "");
337     } else if (data->value == ClickEventType::TOUCH_EVENT_UP) {
338         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_EVENT_TOUCH_DOWN, "");
339     } else if (data->value == ClickEventType::CLICK_EVENT) {
340         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_EVENT_CLICK, "");
341     }
342 }
343 
HandleLoadPage(const std::shared_ptr<ResData>& data)344 void SocPerfPlugin::HandleLoadPage(const std::shared_ptr<ResData>& data)
345 {
346     if (data->value == LOAD_PAGE_START) {
347         SOC_PERF_LOGI("SocPerfPlugin: socperf->PUSH_PAGE_START");
348         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_LOAD_PAGE_START, true, "");
349     } else if (data->value == LOAD_PAGE_COMPLETE) {
350         SOC_PERF_LOGI("SocPerfPlugin: socperf->PUSH_PAGE_COMPLETE");
351         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_LOAD_PAGE_START, false, "");
352         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_LOAD_PAGE_COMPLETE, "");
353     }
354 }
355 
HandlePopPage(const std::shared_ptr<ResData>& data)356 void SocPerfPlugin::HandlePopPage(const std::shared_ptr<ResData>& data)
357 {
358     SOC_PERF_LOGI("SocPerfPlugin: socperf->POP_PAGE: %{public}lld", (long long)data->value);
359     OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_POP_PAGE, "");
360 }
361 
HandleEventSlide(const std::shared_ptr<ResData>& data)362 void SocPerfPlugin::HandleEventSlide(const std::shared_ptr<ResData>& data)
363 {
364     SOC_PERF_LOGD("SocPerfPlugin: socperf->SLIDE_NORMAL: %{public}lld", (long long)data->value);
365     static int counter = 0;
366     static uint64_t lastTime = 0;
367     if (data->value == SlideEventStatus::SLIDE_EVENT_ON || data->value == SlideEventStatus::SLIDE_NORMAL_BEGIN) {
368         auto now = std::chrono::system_clock::now();
369         uint64_t curMs = static_cast<uint64_t>(
370             std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count());
371         if (curMs - lastTime > TIME_INTERVAL) {
372             counter = 0;
373         }
374         lastTime = curMs;
375         counter++;
376         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_EVENT_SLIDE, true, "");
377     } else if (data->value == SlideEventStatus::SLIDE_EVENT_OFF || data->value == SlideEventStatus::SLIDE_NORMAL_END) {
378         counter--;
379         if (counter == 0) {
380             OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_EVENT_SLIDE, false, "");
381         }
382     }
383 }
384 
HandleEventWebGesture(const std::shared_ptr<ResData>& data)385 void SocPerfPlugin::HandleEventWebGesture(const std::shared_ptr<ResData>& data)
386 {
387     if (data == nullptr) {
388         return;
389     }
390     SOC_PERF_LOGD("SocPerfPlugin: socperf->WEB_GESTURE: %{public}lld", (long long)data->value);
391     if (data->value == WebGesture::WEB_GESTURE_START) {
392         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_EVENT_WEB_GESTURE, true, "");
393     } else if (data->value == WebGesture::WEB_GESTURE_END) {
394         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_EVENT_WEB_GESTURE, false, "");
395     }
396 }
397 
HandleResizeWindow(const std::shared_ptr<ResData>& data)398 void SocPerfPlugin::HandleResizeWindow(const std::shared_ptr<ResData>& data)
399 {
400     if (data == nullptr) {
401         return;
402     }
403     SOC_PERF_LOGI("SocPerfPlugin: socperf->RESIZE_WINDOW: %{public}lld", (long long)data->value);
404     if (data->value == WindowResizeType::WINDOW_RESIZING) {
405         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_RESIZE_WINDOW, "");
406     } else if (data->value == WindowResizeType::WINDOW_RESIZE_STOP) {
407         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_RESIZE_WINDOW, false, "");
408     }
409 }
410 
HandleMoveWindow(const std::shared_ptr<ResData>& data)411 void SocPerfPlugin::HandleMoveWindow(const std::shared_ptr<ResData>& data)
412 {
413     if (data == nullptr) {
414         return;
415     }
416     SOC_PERF_LOGI("SocPerfPlugin: socperf->MOVE_WINDOW: %{public}lld", (long long)data->value);
417     if (data->value == WindowMoveType::WINDOW_MOVING) {
418         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_MOVE_WINDOW, "");
419     } else if (data->value == WindowMoveType::WINDOW_MOVE_STOP) {
420         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_MOVE_WINDOW, false, "");
421     }
422 }
423 
HandleRemoteAnimation(const std::shared_ptr<ResData>& data)424 void SocPerfPlugin::HandleRemoteAnimation(const std::shared_ptr<ResData>& data)
425 {
426     SOC_PERF_LOGI("SocPerfPlugin: socperf->REMOTE_ANIMATION: %{public}lld", (long long)data->value);
427     if (data->value == ShowRemoteAnimationStatus::ANIMATION_BEGIN) {
428         SOC_PERF_LOGI("SocPerfPlugin: socperf->REMOTE_ANIMATION: %{public}lld", (long long)data->value);
429         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_REMOTE_ANIMATION, true, "");
430     } else if (data->value == ShowRemoteAnimationStatus::ANIMATION_END) {
431         SOC_PERF_LOGI("SocPerfPlugin: socperf->REMOTE_ANIMATION: %{public}lld", (long long)data->value);
432         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_REMOTE_ANIMATION, false, "");
433     } else if (data->value == ShowRemoteAnimationStatus::ANIMATION_UNLOCK_BEGIN) {
434         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_REMOTE_UNLOCK, true, "");
435     } else if (data->value == ShowRemoteAnimationStatus::ANIMATION_UNLOCK_END) {
436         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_REMOTE_UNLOCK, false, "");
437     }
438 }
439 
HandleDragStatusBar(const std::shared_ptr<ResData>& data)440 void SocPerfPlugin::HandleDragStatusBar(const std::shared_ptr<ResData>& data)
441 {
442     if (data == nullptr) {
443         return;
444     }
445     SOC_PERF_LOGI("SocPerfPlugin: socperf->DRAG_STATUS_BAR: %{public}lld", (long long)data->value);
446     if (data->value == StatusBarDragStatus::DRAG_START) {
447         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_DRAG_STATUS_BAR, "");
448     } else if (data->value == StatusBarDragStatus::DRAG_END) {
449         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_DRAG_STATUS_BAR, false, "");
450     }
451 }
452 
HandleWebGestureMove(const std::shared_ptr<ResData>& data)453 void SocPerfPlugin::HandleWebGestureMove(const std::shared_ptr<ResData>& data)
454 {
455     if (data == nullptr) {
456         return;
457     }
458     SOC_PERF_LOGI("SocPerfPlugin: socperf->WEB_GESTURE_MOVE: %{public}lld", (long long)data->value);
459     if (data->value == WebGestureMove::WEB_GESTURE_MOVE_START) {
460         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_WEB_GESTURE_MOVE, true, "");
461     } else if (data->value == WebGestureMove::WEB_GESTURE_MOVE_END) {
462         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_WEB_GESTURE_MOVE, false, "");
463     }
464 }
465 
HandleWebSlideNormal(const std::shared_ptr<ResData>& data)466 void SocPerfPlugin::HandleWebSlideNormal(const std::shared_ptr<ResData>& data)
467 {
468     if (data == nullptr) {
469         return;
470     }
471     SOC_PERF_LOGD("SocPerfPlugin: socperf->WEB_SLIDE_NORMAL: %{public}lld", (long long)data->value);
472     if (data->value == WebSlideNormal::WEB_SLIDE_NORMAL_START) {
473         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_WEB_SLIDE_NORMAL, true, "");
474     } else if (data->value == WebSlideNormal::WEB_SLIDE_NORMAL_END) {
475         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_WEB_SLIDE_NORMAL, false, "");
476     }
477 }
478 
HandleLoadUrl(const std::shared_ptr<ResData>& data)479 void SocPerfPlugin::HandleLoadUrl(const std::shared_ptr<ResData>& data)
480 {
481     SOC_PERF_LOGI("SocPerfPlugin: socperf->LOAD_URL");
482     OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_LOAD_URL, "");
483 }
484 
HandleMousewheel(const std::shared_ptr<ResData>& data)485 void SocPerfPlugin::HandleMousewheel(const std::shared_ptr<ResData>& data)
486 {
487     SOC_PERF_LOGI("SocPerfPlugin: socperf->MOUSEWHEEL");
488     OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_MOUSEWHEEL, "");
489 }
490 
HandleAppStateChange(const std::shared_ptr<ResData>& data)491 bool SocPerfPlugin::HandleAppStateChange(const std::shared_ptr<ResData>& data)
492 {
493     if (data->value != ResType::ProcessStatus::PROCESS_CREATED) {
494         return false;
495     }
496     int extensionType = ParsePayload(data, EXTENSION_TYPE_KEY);
497     if (std::find(ResType::UI_SENSITIVE_EXTENSION.begin(), ResType::UI_SENSITIVE_EXTENSION.end(), extensionType) !=
498         ResType::UI_SENSITIVE_EXTENSION.end()) {
499         SOC_PERF_LOGI("SocPerfPlugin: socperf->APPSTATECHANGE");
500         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_APP_START, "");
501         return true;
502     }
503     return false;
504 }
505 
HandleDeviceModeStatusChange(const std::shared_ptr<ResData>& data)506 void SocPerfPlugin::HandleDeviceModeStatusChange(const std::shared_ptr<ResData>& data)
507 {
508     if ((data->value != DeviceModeStatus::MODE_ENTER) && (data->value != DeviceModeStatus::MODE_QUIT)) {
509         SOC_PERF_LOGW("SocPerfPlugin: device mode status value is error");
510         return;
511     }
512 
513     if (!data->payload.contains(DEVICE_MODE_PAYMODE_NAME) || !data->payload[DEVICE_MODE_PAYMODE_NAME].is_string()) {
514         SOC_PERF_LOGW("SocPerfPlugin: device mode status payload is error");
515         return;
516     }
517 
518     std::string deviceMode = data->payload[DEVICE_MODE_PAYMODE_NAME];
519     bool status = (data->value == DeviceModeStatus::MODE_ENTER);
520     OHOS::SOCPERF::SocPerfClient::GetInstance().RequestDeviceMode(deviceMode, status);
521     SOC_PERF_LOGI("SocPerfPlugin: device mode %{public}s  status%{public}d", deviceMode.c_str(), status);
522 }
523 
HandleWebDragResize(const std::shared_ptr<ResData>& data)524 void SocPerfPlugin::HandleWebDragResize(const std::shared_ptr<ResData>& data)
525 {
526     if (data == nullptr) {
527         return;
528     }
529     SOC_PERF_LOGI("SocPerfPlugin: socperf->WEB_DRAG_RESIZE: %{public}lld", (long long)data->value);
530     if (data->value == WebDragResizeStatus::WEB_DRAG_START) {
531         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(PERF_REQUEST_CMD_ID_WEB_DRAG_RESIZE, "");
532     } else if (data->value == WebDragResizeStatus::WEB_DRAG_END) {
533         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_WEB_DRAG_RESIZE, false, "");
534     }
535 }
536 
HandleSocperfSceneBoard(const std::shared_ptr<ResData> &data)537 bool SocPerfPlugin::HandleSocperfSceneBoard(const std::shared_ptr<ResData> &data)
538 {
539     if (data == nullptr) {
540         return false;
541     }
542     SOC_PERF_LOGD("SocPerfPlugin: socperf->ANIMATION: %{public}lld", (long long)data->value);
543     if (data->value == ShowRemoteAnimationStatus::ANIMATION_BEGIN) {
544         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_REMOTE_ANIMATION, true, "");
545     } else if (data->value == ShowRemoteAnimationStatus::ANIMATION_END) {
546         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_REMOTE_ANIMATION, false, "");
547     }
548     return true;
549 }
550 
HandleSocperfAccountActivating(const std::shared_ptr<ResData> &data)551 bool SocPerfPlugin::HandleSocperfAccountActivating(const std::shared_ptr<ResData> &data)
552 {
553     if (data == nullptr) {
554         return false;
555     }
556     SOC_PERF_LOGD("SocPerfPlugin: socperf->AccountActivating: %{public}lld", (long long)data->value);
557     if (data->value == AccountActivatingStatus::ACCOUNT_ACTIVATING_START) {
558         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_ACCOUNT_ACTIVATING, true, "");
559     }
560     return true;
561 }
562 
HandleCustEvent(const std::shared_ptr<ResData> &data)563 bool SocPerfPlugin::HandleCustEvent(const std::shared_ptr<ResData> &data)
564 {
565     if (data == nullptr || data->value <= 0) {
566         return false;
567     }
568     SOC_PERF_LOGD("SocPerfPlugin: socperf->Anco: %{public}lld", (long long)data->value);
569     OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequest(data->value, "");
570     return true;
571 }
572 
HandleCustEventBegin(const std::shared_ptr<ResData> &data)573 bool SocPerfPlugin::HandleCustEventBegin(const std::shared_ptr<ResData> &data)
574 {
575     if (data == nullptr || data->value <= 0) {
576         return false;
577     }
578     SOC_PERF_LOGD("SocPerfPlugin: socperf->SOCPERF_CUST_EVENT_BEGIN: %{public}lld", (long long)data->value);
579     OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(data->value, true, "");
580     return true;
581 }
582 
HandleCustEventEnd(const std::shared_ptr<ResData> &data)583 bool SocPerfPlugin::HandleCustEventEnd(const std::shared_ptr<ResData> &data)
584 {
585     if (data == nullptr || data->value <= 0) {
586         return false;
587     }
588     SOC_PERF_LOGD("SocPerfPlugin: socperf->SOCPERF_CUST_EVENT_END: %{public}lld", (long long)data->value);
589     OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(data->value, false, "");
590     return true;
591 }
592 
HandleRgmBootingStatus(const std::shared_ptr<ResData> &data)593 bool SocPerfPlugin::HandleRgmBootingStatus(const std::shared_ptr<ResData> &data)
594 {
595     if (data == nullptr) {
596         return false;
597     }
598     SOC_PERF_LOGD("SocPerfPlugin: socperf->RGM_BOOTING_STATUS: %{public}lld", (long long)data->value);
599     if (data->value == 0) {
600         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_RGM_BOOTING_START, true, "");
601     }
602     return true;
603 }
604 
HandleAppColdStartEx(const std::shared_ptr<ResData> &data)605 bool SocPerfPlugin::HandleAppColdStartEx(const std::shared_ptr<ResData> &data)
606 {
607     if (data == nullptr) {
608         return false;
609     }
610     SOC_PERF_LOGD("SocPerfPlugin: socperf->APP_START_ONLY_PERF: %{public}lld", (long long)data->value);
611     if (data->value == 0) {
612         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_APP_START, true, "");
613     } else if (data->value == 1) {
614         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_APP_START, false, "");
615     }
616     return true;
617 }
618 
HandleSceneRotation(const std::shared_ptr<ResData> &data)619 bool SocPerfPlugin::HandleSceneRotation(const std::shared_ptr<ResData> &data)
620 {
621     if (data == nullptr) {
622         return false;
623     }
624     SOC_PERF_LOGD("SocPerfPlugin: socperf->PERF_REQUEST_CMD_ID_ROTATION: %{public}lld", (long long)data->value);
625     if (data->value == 0) {
626         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_ROTATION, true, "");
627     } else if (data->value == 1) {
628         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_ROTATION, false, "");
629     }
630     return true;
631 }
632 
HandleBmmMoniterStatus(const std::shared_ptr<ResData> &data)633 bool SocPerfPlugin::HandleBmmMoniterStatus(const std::shared_ptr<ResData> &data)
634 {
635     if (data == nullptr) {
636         return false;
637     }
638     SOC_PERF_LOGD("SocPerfPlugin: socperf->PERF_REQUEST_CMD_ID_BMM_MONITER_CHANGE: %{public}lld",
639         (long long)data->value);
640     if (data->value == BmmMoniterStatus::BMM_BACKGROUND) {
641         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_BMM_MONITER_START, true, "");
642         return true;
643     }
644     if (data->value == BmmMoniterStatus::BMM_CLOSE) {
645         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_BMM_MONITER_START, false, "");
646         return true;
647     }
648     return false;
649 }
650 
HandlePowerModeChanged(const std::shared_ptr<ResData> &data)651 bool SocPerfPlugin::HandlePowerModeChanged(const std::shared_ptr<ResData> &data)
652 {
653     if (data == nullptr) {
654         return false;
655     }
656     SOC_PERF_LOGD("SocPerfPlugin: socperf->HandlePowerModeChanged: %{public}lld", (long long)data->value);
657     if (data->value == POWERMODE_ON) {
658         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_POWERMODE_CHANGED, true, "");
659     } else {
660         OHOS::SOCPERF::SocPerfClient::GetInstance().PerfRequestEx(PERF_REQUEST_CMD_ID_POWERMODE_CHANGED, false, "");
661     }
662     return true;
663 }
664 
OnPluginInit(std::string& libName)665 extern "C" bool OnPluginInit(std::string& libName)
666 {
667     if (libName != LIB_NAME) {
668         SOC_PERF_LOGE("SocPerfPlugin::OnPluginInit lib name is not match");
669         return false;
670     }
671     SocPerfPlugin::GetInstance().Init();
672     return true;
673 }
674 
OnPluginDisable()675 extern "C" void OnPluginDisable()
676 {
677     SocPerfPlugin::GetInstance().Disable();
678 }
679 
OnDispatchResource(const std::shared_ptr<ResData>& data)680 extern "C" void OnDispatchResource(const std::shared_ptr<ResData>& data)
681 {
682     SocPerfPlugin::GetInstance().DispatchResource(data);
683 }
684 } // namespace ResourceSchedule
685 } // namespace OHOS
686 #endif // RESSCHED_RESOURCESCHEDULE_SOC_PERF_ENABLE