1 /*
2 * Copyright (c) 2021-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 "dcamera_source_handler.h"
17
18 #include "anonymous_string.h"
19 #include "dcamera_hisysevent_adapter.h"
20 #include "dcamera_source_callback.h"
21 #include "dcamera_source_handler_ipc.h"
22 #include "dcamera_source_load_callback.h"
23 #include "distributed_camera_constants.h"
24 #include "distributed_camera_errno.h"
25 #include "distributed_hardware_log.h"
26 #include "if_system_ability_manager.h"
27 #include "iservice_registry.h"
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 IMPLEMENT_SINGLE_INSTANCE(DCameraSourceHandler);
32
DCameraSourceHandler()33 DCameraSourceHandler::DCameraSourceHandler()
34 {
35 DHLOGI("DCameraSourceHandler construct.");
36 callback_ = new DCameraSourceCallback();
37 }
38
~DCameraSourceHandler()39 DCameraSourceHandler::~DCameraSourceHandler()
40 {
41 DHLOGI("~DCameraSourceHandler");
42 }
43
InitSource(const std::string & params)44 int32_t DCameraSourceHandler::InitSource(const std::string& params)
45 {
46 DHLOGI("DCameraSourceHandler InitSource Start");
47 {
48 std::lock_guard<std::mutex> autoLock(producerMutex_);
49 if (state_ == DCAMERA_SA_STATE_START) {
50 return DCAMERA_OK;
51 }
52 }
53 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
54 if (sm == nullptr) {
55 DHLOGE("GetSourceLocalCamSrv GetSystemAbilityManager failed");
56 return DCAMERA_INIT_ERR;
57 }
58 ReportSaEvent(INIT_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "init source sa event.");
59 sptr<DCameraSourceLoadCallback> loadCallback = new DCameraSourceLoadCallback(params);
60 int32_t ret = sm->LoadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, loadCallback);
61 if (ret != ERR_OK) {
62 DHLOGE("systemAbilityId: %d load failed, result code: %d.", DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, ret);
63 return DCAMERA_INIT_ERR;
64 }
65 {
66 uint32_t interval = 1;
67 std::unique_lock<std::mutex> lock(producerMutex_);
68 producerCon_.wait_for(lock, std::chrono::minutes(interval), [this] {
69 return (this->state_ == DCAMERA_SA_STATE_START);
70 });
71 if (state_ == DCAMERA_SA_STATE_STOP) {
72 DHLOGE("SourceSA Start failed!");
73 return DCAMERA_INIT_ERR;
74 }
75 }
76 DHLOGI("DCameraSourceHandler InitSource end, result: %d", ret);
77 return DCAMERA_OK;
78 }
79
FinishStartSA(const std::string & params)80 void DCameraSourceHandler::FinishStartSA(const std::string ¶ms)
81 {
82 DCameraSourceHandlerIpc::GetInstance().Init();
83 sptr<IDistributedCameraSource> dCameraSourceSrv = DCameraSourceHandlerIpc::GetInstance().GetSourceLocalCamSrv();
84 if (dCameraSourceSrv == nullptr) {
85 DHLOGE("DCameraSourceHandler InitSource get Service failed");
86 return;
87 }
88
89 dCameraSourceSrv->InitSource(params, callback_);
90 std::lock_guard<std::mutex> lock(producerMutex_);
91 state_ = DCAMERA_SA_STATE_START;
92 producerCon_.notify_one();
93 }
94
FinishStartSAFailed(const int32_t systemAbilityId)95 void DCameraSourceHandler::FinishStartSAFailed(const int32_t systemAbilityId)
96 {
97 DHLOGE("SourceSA Start failed, systemAbilityId: %d.", systemAbilityId);
98 std::unique_lock<std::mutex> lock(producerMutex_);
99 state_ = DCAMERA_SA_STATE_STOP;
100 producerCon_.notify_one();
101 }
102
ReleaseSource()103 int32_t DCameraSourceHandler::ReleaseSource()
104 {
105 DHLOGI("DCameraSourceHandler ReleaseSource Start");
106 sptr<IDistributedCameraSource> dCameraSourceSrv = DCameraSourceHandlerIpc::GetInstance().GetSourceLocalCamSrv();
107 if (dCameraSourceSrv == nullptr) {
108 DHLOGE("DCameraSourceHandler ReleaseSource get Service failed");
109 return DCAMERA_INIT_ERR;
110 }
111 ReportSaEvent(RELEASE_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "release source sa event.");
112 dCameraSourceSrv->ReleaseSource();
113 DCameraSourceHandlerIpc::GetInstance().UnInit();
114 std::unique_lock<std::mutex> lock(producerMutex_);
115 state_ = DCAMERA_SA_STATE_STOP;
116 DHLOGI("DCameraSourceHandler ReleaseSource end");
117 return DCAMERA_OK;
118 }
119
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,std::shared_ptr<RegisterCallback> callback)120 int32_t DCameraSourceHandler::RegisterDistributedHardware(const std::string& devId, const std::string& dhId,
121 const EnableParam& param, std::shared_ptr<RegisterCallback> callback)
122 {
123 DHLOGI("DCameraSourceHandler RegisterDistributedHardware devId: %s dhId: %s", GetAnonyString(devId).c_str(),
124 GetAnonyString(dhId).c_str());
125 if (callback == nullptr) {
126 DHLOGI("DCameraSourceHandler RegisterDistributedHardware RegisterCallback is null.");
127 return DCAMERA_BAD_VALUE;
128 }
129 sptr<IDistributedCameraSource> dCameraSourceSrv = DCameraSourceHandlerIpc::GetInstance().GetSourceLocalCamSrv();
130 if (dCameraSourceSrv == nullptr) {
131 DHLOGE("DCameraSourceHandler RegisterDistributedHardware get Service failed");
132 return DCAMERA_BAD_VALUE;
133 }
134
135 std::string reqId = GetRandomID();
136 std::lock_guard<std::mutex> autoLock(optLock_);
137
138 callback_->PushRegCallback(reqId, callback);
139 int32_t ret = dCameraSourceSrv->RegisterDistributedHardware(devId, dhId, reqId, param);
140 if (ret != DCAMERA_OK) {
141 callback_->PopRegCallback(reqId);
142 }
143 DHLOGI("DCameraSourceHandler RegisterDistributedHardware end, ret: %d devId: %s dhId: %s version: %s",
144 ret, GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.version.c_str());
145 return ret;
146 }
147
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,std::shared_ptr<UnregisterCallback> callback)148 int32_t DCameraSourceHandler::UnregisterDistributedHardware(const std::string& devId, const std::string& dhId,
149 std::shared_ptr<UnregisterCallback> callback)
150 {
151 DHLOGI("DCameraSourceHandler UnregisterDistributedHardware devId: %s dhId: %s", GetAnonyString(devId).c_str(),
152 GetAnonyString(dhId).c_str());
153 if (callback == nullptr) {
154 DHLOGI("DCameraSourceHandler RegisterDistributedHardware UnregisterCallback is null.");
155 return DCAMERA_BAD_VALUE;
156 }
157 sptr<IDistributedCameraSource> dCameraSourceSrv = DCameraSourceHandlerIpc::GetInstance().GetSourceLocalCamSrv();
158 if (dCameraSourceSrv == nullptr) {
159 DHLOGE("DCameraSourceHandler UnregisterDistributedHardware get Service failed");
160 return DCAMERA_BAD_VALUE;
161 }
162
163 std::string reqId = GetRandomID();
164 std::lock_guard<std::mutex> autoLock(optLock_);
165
166 callback_->PushUnregCallback(reqId, callback);
167 int32_t ret = dCameraSourceSrv->UnregisterDistributedHardware(devId, dhId, reqId);
168 if (ret != DCAMERA_OK) {
169 callback_->PopUnregCallback(reqId);
170 }
171 DHLOGI("DCameraSourceHandler UnregisterDistributedHardware end, ret: %d devId: %s dhId: %s", ret,
172 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
173 return ret;
174 }
175
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)176 int32_t DCameraSourceHandler::ConfigDistributedHardware(const std::string& devId, const std::string& dhId,
177 const std::string& key, const std::string& value)
178 {
179 return DCAMERA_OK;
180 }
181
GetSourceHardwareHandler()182 IDistributedHardwareSource *GetSourceHardwareHandler()
183 {
184 DHLOGI("DCameraSourceHandler GetSourceHardwareHandler Start");
185 return &DCameraSourceHandler::GetInstance();
186 }
187 } // namespace DistributedHardware
188 } // namespace OHOS
189