1 /*
2 * Copyright (c) 2023-2023 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 "hstream_operator_manager.h"
17 #include "hstream_operator.h"
18 #include "camera_dynamic_loader.h"
19 #include "camera_log.h"
20
21 namespace OHOS {
22 namespace CameraStandard {
23 sptr<HStreamOperatorManager> HStreamOperatorManager::streamOperatorManager_;
24 std::mutex HStreamOperatorManager::instanceMutex_;
25
HStreamOperatorManager()26 HStreamOperatorManager::HStreamOperatorManager() {}
27
~HStreamOperatorManager()28 HStreamOperatorManager::~HStreamOperatorManager()
29 {
30 HStreamOperatorManager::streamOperatorManager_ = nullptr;
31 }
32
GetInstance()33 sptr<HStreamOperatorManager> &HStreamOperatorManager::GetInstance()
34 {
35 if (HStreamOperatorManager::streamOperatorManager_ == nullptr) {
36 std::unique_lock<std::mutex> lock(instanceMutex_);
37 if (HStreamOperatorManager::streamOperatorManager_ == nullptr) {
38 MEDIA_INFO_LOG("Initializing stream operator manager instance");
39 HStreamOperatorManager::streamOperatorManager_ = new HStreamOperatorManager();
40 }
41 }
42 return HStreamOperatorManager::streamOperatorManager_;
43 }
44
AddStreamOperator(sptr<HStreamOperator> hStreamOperator)45 void HStreamOperatorManager::AddStreamOperator(sptr<HStreamOperator> hStreamOperator)
46 {
47 std::lock_guard<std::mutex> lock(mapMutex_);
48 MEDIA_INFO_LOG("HStreamOperatorManager::AddStreamOperator start");
49 int32_t streamOperatorId = GenerateStreamOperatorId();
50 streamOperatorManagerMap_[streamOperatorId] = hStreamOperator;
51 hStreamOperator->SetStreamOperatorId(streamOperatorId);
52 MEDIA_INFO_LOG("HStreamOperatorManager::AddStreamOperator end hStreamOperatorId is %{public}d", streamOperatorId);
53 return;
54 }
55
RemoveStreamOperator(int32_t & hStreamOperatorId)56 void HStreamOperatorManager::RemoveStreamOperator(int32_t& hStreamOperatorId)
57 {
58 MEDIA_INFO_LOG("HStreamOperatorManager::RemoveStreamOperator hStreamOperatorId is %{public}d", hStreamOperatorId);
59 std::lock_guard<std::mutex> lock(mapMutex_);
60 if (hStreamOperatorId < 0) {
61 return;
62 }
63 auto streamOperator = streamOperatorManagerMap_.find(hStreamOperatorId);
64 if (streamOperator == streamOperatorManagerMap_.end()) {
65 return;
66 }
67 streamOperatorManagerMap_.erase(hStreamOperatorId);
68 if (streamOperatorManagerMap_.size() == 0) {
69 CameraDynamicLoader::FreeDynamiclib(MEDIA_LIB_SO);
70 }
71 MEDIA_INFO_LOG("HStreamOperatorManager::RemoveStreamOperator end");
72 return;
73 }
74
UpdateStreamOperator(int32_t & hStreamOperatorId)75 void HStreamOperatorManager::UpdateStreamOperator(int32_t& hStreamOperatorId)
76 {
77 std::lock_guard<std::mutex> lock(mapMutex_);
78 MEDIA_INFO_LOG("HStreamOperatorManager::UpdateStreamOperator hStreamOperatorId is %{public}d", hStreamOperatorId);
79 auto StreamOperator = streamOperatorManagerMap_.find(hStreamOperatorId);
80 if (StreamOperator == streamOperatorManagerMap_.end()) {
81 return;
82 }
83 }
84
GetOfflineOutputSize()85 int32_t HStreamOperatorManager::GetOfflineOutputSize()
86 {
87 MEDIA_INFO_LOG("HStreamOperatorManager::DfxReport size is %{public}zu", streamOperatorManagerMap_.size());
88 int32_t offlineOutputCount = 0;
89 for (auto streamOperator : streamOperatorManagerMap_) {
90 int32_t tempSize = (streamOperator.second)->GetOfflineOutptSize();
91 offlineOutputCount = offlineOutputCount + tempSize;
92 }
93 if (offlineOutputCount > 2) { // 2 is the threshold of the statistics
94 MEDIA_INFO_LOG("HStreamOperatorManager::DfxReport offlineOutputCount is %{public}d", offlineOutputCount);
95 }
96 return offlineOutputCount;
97 }
98
GetStreamOperatorByPid(pid_t pidRequest)99 std::vector<sptr<HStreamOperator>> HStreamOperatorManager::GetStreamOperatorByPid(pid_t pidRequest)
100 {
101 std::lock_guard<std::mutex> lock(mapMutex_);
102 std::vector<sptr<HStreamOperator>> streamOperatorVec = {};
103 for (auto streamOperator : streamOperatorManagerMap_) {
104 if (pidRequest == (streamOperator.second)->GetPid()) {
105 streamOperatorVec.push_back(streamOperator.second);
106 MEDIA_INFO_LOG("HStreamOperatorManager::GetCameraByPid find");
107 }
108 }
109 MEDIA_INFO_LOG("HStreamOperatorManager::GetStreamOperatorByPid pid is %{public}d size is %{public}zu", pidRequest,
110 streamOperatorVec.size());
111 return streamOperatorVec;
112 }
113 } // namespace CameraStandard
114 } // namespace OHOS
115