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