1 /*
2 * Copyright (c) 2021-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 "distributed_camera_source_service.h"
17
18 #include "if_system_ability_manager.h"
19 #include "ipc_skeleton.h"
20 #include "ipc_types.h"
21 #include "iservice_registry.h"
22 #include "string_ex.h"
23 #include "system_ability_definition.h"
24
25 #include "anonymous_string.h"
26 #include "dcamera_hdf_operate.h"
27 #include "dcamera_hisysevent_adapter.h"
28 #include "dcamera_hitrace_adapter.h"
29 #include "dcamera_service_state_listener.h"
30 #include "dcamera_source_service_ipc.h"
31 #include "distributed_camera_errno.h"
32 #include "distributed_hardware_log.h"
33
34 namespace OHOS {
35 namespace DistributedHardware {
36 REGISTER_SYSTEM_ABILITY_BY_ID(DistributedCameraSourceService, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, true);
37
38 std::map<DCameraIndex, std::shared_ptr<DCameraSourceDev>> DistributedCameraSourceService::camerasMap_;
39 std::mutex DistributedCameraSourceService::camDevMutex_;
40
DistributedCameraSourceService(int32_t saId,bool runOnCreate)41 DistributedCameraSourceService::DistributedCameraSourceService(int32_t saId, bool runOnCreate)
42 : SystemAbility(saId, runOnCreate)
43 {
44 }
45
OnStart()46 void DistributedCameraSourceService::OnStart()
47 {
48 DHLOGI("start");
49 if (state_ == DCameraServiceState::DCAMERA_SRV_STATE_RUNNING) {
50 DHLOGI("DistributedCameraSourceService has already started.");
51 return;
52 }
53
54 if (!Init()) {
55 DHLOGE("DistributedCameraSourceService init failed");
56 return;
57 }
58 state_ = DCameraServiceState::DCAMERA_SRV_STATE_RUNNING;
59 DHLOGI("start service success.");
60 }
61
Init()62 bool DistributedCameraSourceService::Init()
63 {
64 DHLOGI("DistributedCameraSourceService start init");
65 DCameraSourceServiceIpc::GetInstance().Init();
66 if (!registerToService_) {
67 bool ret = Publish(this);
68 if (!ret) {
69 DHLOGE("DistributedCameraSourceService Publish service failed");
70 return false;
71 }
72 registerToService_ = true;
73 }
74 listener_ = std::make_shared<DCameraServiceStateListener>();
75 DHLOGI("DistributedCameraSourceService init success");
76 return true;
77 }
78
OnStop()79 void DistributedCameraSourceService::OnStop()
80 {
81 DHLOGI("DistributedCameraSourceService OnStop service");
82 state_ = DCameraServiceState::DCAMERA_SRV_STATE_NOT_START;
83 registerToService_ = false;
84 listener_ = nullptr;
85 DCameraSourceServiceIpc::GetInstance().UnInit();
86 }
87
InitSource(const std::string & params,const sptr<IDCameraSourceCallback> & callback)88 int32_t DistributedCameraSourceService::InitSource(const std::string& params,
89 const sptr<IDCameraSourceCallback>& callback)
90 {
91 DHLOGI("DistributedCameraSourceService InitSource param: %s", params.c_str());
92 int32_t ret = LoadDCameraHDF();
93 if (ret != DCAMERA_OK) {
94 DHLOGE("DistributedCameraSourceService InitSource LoadHDF failed, ret: %d", ret);
95 return ret;
96 }
97 sourceVer_ = params;
98 if (listener_ != nullptr) {
99 listener_->SetCallback(callback);
100 }
101 return DCAMERA_OK;
102 }
103
ReleaseSource()104 int32_t DistributedCameraSourceService::ReleaseSource()
105 {
106 DHLOGI("enter");
107 int32_t ret = UnLoadCameraHDF();
108 if (ret != DCAMERA_OK) {
109 DHLOGE("DistributedCameraSourceService ReleaseSource UnLoadHDF failed, ret: %d", ret);
110 return ret;
111 }
112
113 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
114 if (systemAbilityMgr == nullptr) {
115 DHLOGE("source systemAbilityMgr is null");
116 return DCAMERA_BAD_VALUE;
117 }
118 ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID);
119 if (ret != DCAMERA_OK) {
120 DHLOGE("source systemAbilityMgr UnLoadSystemAbility failed, ret: %d", ret);
121 return DCAMERA_BAD_VALUE;
122 }
123 DHLOGI("source systemAbilityMgr UnLoadSystemAbility success");
124 return DCAMERA_OK;
125 }
126
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId,const EnableParam & param)127 int32_t DistributedCameraSourceService::RegisterDistributedHardware(const std::string& devId, const std::string& dhId,
128 const std::string& reqId, const EnableParam& param)
129 {
130 DHLOGI("RegisterDistributedHardware devId: %s, dhId: %s, version: %s",
131 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.version.c_str());
132 if (GetCamDevNum() > MAX_CAMERAS_NUMBER) {
133 DHLOGE("cameras exceed the upper limit");
134 return DCAMERA_BAD_VALUE;
135 }
136 DCameraIndex camIndex(devId, dhId);
137 int32_t ret = DCAMERA_OK;
138 std::shared_ptr<DCameraSourceDev> camDev = GetCamDevByIndex(camIndex);
139 if (camDev == nullptr) {
140 DHLOGI("new dev devId: %s, dhId: %s, version: %s",
141 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.version.c_str());
142 camDev = std::make_shared<DCameraSourceDev>(devId, dhId, listener_);
143 ret = camDev->InitDCameraSourceDev();
144 if (ret != DCAMERA_OK) {
145 DHLOGE("RegisterDistributedHardware failed %d InitDev devId: %s, dhId: %s",
146 ret, GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
147 return ret;
148 }
149 CamDevInsert(camIndex, camDev);
150 } else {
151 DHLOGE("RegisterDistributedHardware exist devId: %s, dhId: %s, version: %s",
152 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.version.c_str());
153 return DCAMERA_ALREADY_EXISTS;
154 }
155
156 ret = camDev->RegisterDistributedHardware(devId, dhId, reqId, param.version, param.attrs);
157 if (ret != DCAMERA_OK) {
158 DHLOGE("RegisterDistributedHardware failed, ret: %d", ret);
159 ReportRegisterCameraFail(DCAMERA_REGISTER_FAIL, GetAnonyString(devId), dhId, param.version,
160 "dcamera source RegisterDistributedHardware fail.");
161 CamDevErase(camIndex);
162 }
163 DHLOGI("RegisterDistributedHardware end devId: %s, dhId: %s, version: %s",
164 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.version.c_str());
165 return ret;
166 }
167
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId)168 int32_t DistributedCameraSourceService::UnregisterDistributedHardware(const std::string& devId, const std::string& dhId,
169 const std::string& reqId)
170 {
171 DHLOGI("UnregisterDistributedHardware devId: %s, dhId: %s",
172 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
173 DCameraIndex camIndex(devId, dhId);
174 std::shared_ptr<DCameraSourceDev> camDev = GetCamDevByIndex(camIndex);
175 if (camDev == nullptr) {
176 DHLOGE("DistributedCameraSourceService UnregisterDistributedHardware not found device");
177 return DCAMERA_NOT_FOUND;
178 }
179
180 int32_t ret = camDev->UnRegisterDistributedHardware(devId, dhId, reqId);
181 if (ret != DCAMERA_OK) {
182 DHLOGE("UnregisterDistributedHardware failed, ret: %d", ret);
183 }
184 return ret;
185 }
186
DCameraNotify(const std::string & devId,const std::string & dhId,std::string & events)187 int32_t DistributedCameraSourceService::DCameraNotify(const std::string& devId, const std::string& dhId,
188 std::string& events)
189 {
190 DHLOGI("DCameraNotify devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
191 GetAnonyString(dhId).c_str());
192 DCameraIndex camIndex(devId, dhId);
193 std::shared_ptr<DCameraSourceDev> camDev = GetCamDevByIndex(camIndex);
194 if (camDev == nullptr) {
195 DHLOGE("DistributedCameraSourceService DCameraNotify not found device");
196 return DCAMERA_NOT_FOUND;
197 }
198
199 int32_t ret = camDev->DCameraNotify(events);
200 if (ret != DCAMERA_OK) {
201 DHLOGE("DCameraNotify failed, ret: %d", ret);
202 }
203 return ret;
204 }
205
LoadDCameraHDF()206 int32_t DistributedCameraSourceService::LoadDCameraHDF()
207 {
208 DCAMERA_SYNC_TRACE(DCAMERA_LOAD_HDF);
209 DHLOGI("load hdf driver start");
210 int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl();
211 if (ret != DCAMERA_OK) {
212 DHLOGE("load hdf driver failed, ret %d", ret);
213 ReportDcamerInitFail(DCAMERA_INIT_FAIL, DCAMERA_HDF_ERROR, CreateMsg("dcamera load hdf driver fail."));
214 return ret;
215 }
216 DHLOGI("load hdf driver end");
217 return DCAMERA_OK;
218 }
219
UnLoadCameraHDF()220 int32_t DistributedCameraSourceService::UnLoadCameraHDF()
221 {
222 DHLOGI("unload hdf driver start");
223 int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl();
224 if (ret != DCAMERA_OK) {
225 DHLOGE("unload hdf driver failed, ret %d", ret);
226 return ret;
227 }
228 DHLOGI("unload hdf driver end");
229 return DCAMERA_OK;
230 }
231
Dump(int32_t fd,const std::vector<std::u16string> & args)232 int DistributedCameraSourceService::Dump(int32_t fd, const std::vector<std::u16string>& args)
233 {
234 DHLOGI("DistributedCameraSourceService Dump.");
235 if (args.size() > DUMP_MAX_SIZE) {
236 DHLOGE("DistributedCameraSourceService Dump input is invalid");
237 return DCAMERA_BAD_VALUE;
238 }
239 std::string result;
240 std::vector<std::string> argsStr;
241 for (auto item : args) {
242 argsStr.emplace_back(Str16ToStr8(item));
243 }
244
245 if (!DcameraSourceHidumper::GetInstance().Dump(argsStr, result)) {
246 DHLOGE("Hidump error");
247 return DCAMERA_BAD_VALUE;
248 }
249
250 int ret = dprintf(fd, "%s\n", result.c_str());
251 if (ret < 0) {
252 DHLOGE("dprintf error");
253 return DCAMERA_BAD_VALUE;
254 }
255
256 return DCAMERA_OK;
257 }
258
GetDumpInfo(CameraDumpInfo & camDump)259 void DistributedCameraSourceService::GetDumpInfo(CameraDumpInfo& camDump)
260 {
261 std::lock_guard<std::mutex> camLock(camDevMutex_);
262 camDump.regNumber = static_cast<int32_t>(camerasMap_.size());
263 std::map<std::string, int32_t> curState;
264 for (auto it = camerasMap_.begin(); it != camerasMap_.end(); it++) {
265 DCameraIndex cam = it->first;
266 std::shared_ptr<DCameraSourceDev> camSourceDev = it->second;
267 camDump.version = camSourceDev->GetVersion();
268 std::string deviceId = GetAnonyString(cam.devId_);
269 deviceId.append(cam.dhId_);
270 int32_t devState = camSourceDev->GetStateInfo();
271 curState[deviceId] = devState;
272 }
273 camDump.curState = curState;
274 }
275
CamDevInsert(DCameraIndex & index,std::shared_ptr<DCameraSourceDev> & camDev)276 void DistributedCameraSourceService::CamDevInsert(DCameraIndex& index, std::shared_ptr<DCameraSourceDev>& camDev)
277 {
278 std::lock_guard<std::mutex> camLock(camDevMutex_);
279 camerasMap_.emplace(index, camDev);
280 }
281
GetCamDevByIndex(DCameraIndex & index)282 std::shared_ptr<DCameraSourceDev> DistributedCameraSourceService::GetCamDevByIndex(DCameraIndex& index)
283 {
284 std::lock_guard<std::mutex> camLock(camDevMutex_);
285 auto iter = camerasMap_.find(index);
286 if (iter == camerasMap_.end()) {
287 return nullptr;
288 }
289 return iter->second;
290 }
291
CamDevErase(DCameraIndex & index)292 void DistributedCameraSourceService::CamDevErase(DCameraIndex& index)
293 {
294 std::lock_guard<std::mutex> camLock(camDevMutex_);
295 camerasMap_.erase(index);
296 }
297
GetCamDevNum()298 uint32_t DistributedCameraSourceService::GetCamDevNum()
299 {
300 std::lock_guard<std::mutex> camLock(camDevMutex_);
301 return camerasMap_.size();
302 }
303 } // namespace DistributedHardware
304 } // namespace OHOS
305