1 /*
2 * Copyright (c) 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 #include "background_sensitive_task_overlapping_scene_recognizer.h"
17 #include "continuous_app_install_recognizer.h"
18 #include "slide_recognizer.h"
19 #include "res_sched_log.h"
20 #include "scene_recognizer_mgr.h"
21 #include "system_upgrade_scene_recognizer.h"
22
23 namespace OHOS {
24 namespace ResourceSchedule {
25 IMPLEMENT_SINGLE_INSTANCE(SceneRecognizerMgr);
26
SceneRecognizerMgr()27 SceneRecognizerMgr::SceneRecognizerMgr()
28 {
29 sceneRecognizers_ = {
30 { RecognizeType::CONTINUOUS_APP_INSTALL_RECOGNIZER, std::make_shared<ContinuousAppInstallRecognizer>() },
31 { RecognizeType::SYSTEM_UPGRADE_SCENE_RECOGNIZER, std::make_shared<SystemUpgradeSceneRecognizer>() },
32 { RecognizeType::BACKGROUND_SENSITIVE_TASK_OVERLAPPING_SCENE_RECOGNIZER,
33 std::make_shared<BackgroundSensitiveTaskOverlappingSceneRecognizer>() },
34 { RecognizeType::SLIDE_RECOGNIZER, std::make_shared<SlideRecognizer>()},
35 };
36 ffrtQueue_ = std::make_shared<ffrt::queue>("scene_recognizers_queue",
37 ffrt::queue_attr().qos(ffrt::qos_user_interactive));
38 }
39
~SceneRecognizerMgr()40 SceneRecognizerMgr::~SceneRecognizerMgr()
41 {
42 sceneRecognizers_.clear();
43 if (ffrtQueue_ != nullptr) {
44 ffrtQueue_.reset();
45 }
46 RESSCHED_LOGI("~SceneRecognizerMgr");
47 }
48
DispatchResource(uint32_t resType,int64_t value,const nlohmann::json & payload)49 void SceneRecognizerMgr::DispatchResource(uint32_t resType, int64_t value, const nlohmann::json& payload)
50 {
51 if (ffrtQueue_ == nullptr) {
52 return;
53 }
54 for (auto recognizerItem : sceneRecognizers_) {
55 auto recognizer = recognizerItem.second;
56 ffrtQueue_->submit([resType, value, payload, recognizer]() {
57 recognizer->OnDispatchResource(resType, value, payload);
58 });
59 }
60 }
61
SetListFlingTimeoutTime(int64_t value)62 void SceneRecognizerMgr::SetListFlingTimeoutTime(int64_t value)
63 {
64 std::static_pointer_cast<SlideRecognizer>(sceneRecognizers_[RecognizeType::SLIDE_RECOGNIZER])->
65 SetListFlingTimeoutTime(value);
66 }
67
SetListFlingEndTime(int64_t value)68 void SceneRecognizerMgr::SetListFlingEndTime(int64_t value)
69 {
70 std::static_pointer_cast<SlideRecognizer>(sceneRecognizers_[RecognizeType::SLIDE_RECOGNIZER])->
71 SetListFlingEndTime(value);
72 }
SetListFlingSpeedLimit(float value)73 void SceneRecognizerMgr::SetListFlingSpeedLimit(float value)
74 {
75 std::static_pointer_cast<SlideRecognizer>(sceneRecognizers_[RecognizeType::SLIDE_RECOGNIZER])->
76 SetListFlingSpeedLimit(value);
77 }
SetSlideNormalDetectingTime(int64_t value)78 void SceneRecognizerMgr::SetSlideNormalDetectingTime(int64_t value)
79 {
80 std::static_pointer_cast<SlideRecognizer>(sceneRecognizers_[RecognizeType::SLIDE_RECOGNIZER])->
81 SetSlideNormalDetectingTime(value);
82 }
83
84 extern "C" {
SetListFlingTimeoutTime(int64_t value)85 void SetListFlingTimeoutTime(int64_t value)
86 {
87 SceneRecognizerMgr::GetInstance().SetListFlingTimeoutTime(value);
88 }
SetListFlingEndTime(int64_t value)89 void SetListFlingEndTime(int64_t value)
90 {
91 SceneRecognizerMgr::GetInstance().SetListFlingEndTime(value);
92 }
SetListFlingSpeedLimit(float value)93 void SetListFlingSpeedLimit(float value)
94 {
95 SceneRecognizerMgr::GetInstance().SetListFlingSpeedLimit(value);
96 }
SetSlideNormalDetectingTime(int64_t value)97 void SetSlideNormalDetectingTime(int64_t value)
98 {
99 SceneRecognizerMgr::GetInstance().SetSlideNormalDetectingTime(value);
100 }
101 }
102 } // namespace ResourceSchedule
103 } // namespace OHOS