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 #include "xcollie/watchdog.h"
25 
26 #include "anonymous_string.h"
27 #include "avcodec_info.h"
28 #include "avcodec_list.h"
29 #include "dcamera_hdf_operate.h"
30 #include "dcamera_hisysevent_adapter.h"
31 #include "dcamera_hitrace_adapter.h"
32 #include "dcamera_service_state_listener.h"
33 #include "dcamera_source_service_ipc.h"
34 #include "dcamera_utils_tools.h"
35 #include "distributed_camera_errno.h"
36 #include "distributed_hardware_log.h"
37 #include "dcamera_handler.h"
38 
39 namespace OHOS {
40 namespace DistributedHardware {
41 REGISTER_SYSTEM_ABILITY_BY_ID(DistributedCameraSourceService, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, true);
42 
43 std::map<DCameraIndex, std::shared_ptr<DCameraSourceDev>> DistributedCameraSourceService::camerasMap_;
44 std::mutex DistributedCameraSourceService::camDevMutex_;
45 
DistributedCameraSourceService(int32_t saId,bool runOnCreate)46 DistributedCameraSourceService::DistributedCameraSourceService(int32_t saId, bool runOnCreate)
47     : SystemAbility(saId, runOnCreate)
48 {
49 }
50 
OnStart()51 void DistributedCameraSourceService::OnStart()
52 {
53     DHLOGI("start");
54     if (state_ == DCameraServiceState::DCAMERA_SRV_STATE_RUNNING) {
55         DHLOGI("DistributedCameraSourceService has already started.");
56         return;
57     }
58 
59     if (!Init()) {
60         DHLOGE("DistributedCameraSourceService init failed");
61         return;
62     }
63 #ifdef DCAMERA_MMAP_RESERVE
64     ConverterHandle::GetInstance().InitConverter();
65 #endif
66     state_ = DCameraServiceState::DCAMERA_SRV_STATE_RUNNING;
67     DHLOGI("start service success.");
68 }
69 
Init()70 bool DistributedCameraSourceService::Init()
71 {
72     DHLOGI("DistributedCameraSourceService start init");
73     DCameraSourceServiceIpc::GetInstance().Init();
74     if (!registerToService_) {
75         bool ret = Publish(this);
76         if (!ret) {
77             DHLOGE("DistributedCameraSourceService Publish service failed");
78             return false;
79         }
80         registerToService_ = true;
81     }
82     listener_ = std::make_shared<DCameraServiceStateListener>();
83     if (!isHicollieRunning_.load()) {
84         isHicollieRunning_.store(true);
85         hicollieThread_ = std::thread([this]() { this->StartHicollieThread(); });
86     }
87     DHLOGI("DistributedCameraSourceService init success");
88     return true;
89 }
90 
OnStop()91 void DistributedCameraSourceService::OnStop()
92 {
93     DHLOGI("DistributedCameraSourceService OnStop service");
94     state_ = DCameraServiceState::DCAMERA_SRV_STATE_NOT_START;
95     registerToService_ = false;
96     listener_ = nullptr;
97     DCameraSourceServiceIpc::GetInstance().UnInit();
98     isHicollieRunning_.store(false);
99     if (hicollieThread_.joinable()) {
100         hicollieThread_.join();
101     }
102 #ifdef DCAMERA_MMAP_RESERVE
103     ConverterHandle::GetInstance().DeInitConverter();
104 #endif
105 }
106 
InitSource(const std::string & params,const sptr<IDCameraSourceCallback> & callback)107 int32_t DistributedCameraSourceService::InitSource(const std::string& params,
108     const sptr<IDCameraSourceCallback>& callback)
109 {
110     DHLOGI("DistributedCameraSourceService InitSource param: %{public}s", params.c_str());
111     int32_t ret = LoadDCameraHDF();
112     if (ret != DCAMERA_OK) {
113         DHLOGE("DistributedCameraSourceService InitSource LoadHDF failed, ret: %{public}d", ret);
114         return ret;
115     }
116     sourceVer_ = params;
117     if (listener_ != nullptr) {
118         listener_->SetCallback(callback);
119     }
120     return DCAMERA_OK;
121 }
122 
ReleaseSource()123 int32_t DistributedCameraSourceService::ReleaseSource()
124 {
125     DHLOGI("enter");
126     int32_t ret = UnLoadCameraHDF();
127     if (ret != DCAMERA_OK) {
128         DHLOGE("DistributedCameraSourceService ReleaseSource UnLoadHDF failed, ret: %{public}d", ret);
129         return ret;
130     }
131 
132     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
133     if (systemAbilityMgr == nullptr) {
134         DHLOGE("source systemAbilityMgr is null");
135         return DCAMERA_BAD_VALUE;
136     }
137     ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID);
138     if (ret != DCAMERA_OK) {
139         DHLOGE("source systemAbilityMgr UnLoadSystemAbility failed, ret: %{public}d", ret);
140         return DCAMERA_BAD_VALUE;
141     }
142     DHLOGI("source systemAbilityMgr UnLoadSystemAbility success");
143     return DCAMERA_OK;
144 }
145 
GetCodecInfo()146 std::string DistributedCameraSourceService::GetCodecInfo()
147 {
148     DHLOGI("Create avCodecList start");
149     std::string sourceAttrs = "";
150     cJSON *root = cJSON_CreateObject();
151     if (root == nullptr) {
152         return sourceAttrs;
153     }
154     std::shared_ptr<MediaAVCodec::AVCodecList> avCodecList = MediaAVCodec::AVCodecListFactory::CreateAVCodecList();
155     if (avCodecList == nullptr) {
156         DHLOGI("Create avCodecList failed");
157         cJSON_Delete(root);
158         return sourceAttrs;
159     }
160     const std::vector<std::string> encoderName = {std::string(MediaAVCodec::CodecMimeType::VIDEO_AVC),
161                                                   std::string(MediaAVCodec::CodecMimeType::VIDEO_HEVC)};
162     cJSON *array = cJSON_CreateArray();
163     if (array == nullptr) {
164         DHLOGI("Create arrray failed");
165         cJSON_Delete(root);
166         return sourceAttrs;
167     }
168     for (auto &coder : encoderName) {
169         MediaAVCodec::CapabilityData *capData = avCodecList->GetCapability(coder, true,
170             MediaAVCodec::AVCodecCategory::AVCODEC_HARDWARE);
171         if (capData == nullptr) {
172             continue;
173         }
174         std::string mimeType = capData->mimeType;
175         cJSON_AddItemToArray(array, cJSON_CreateString(mimeType.c_str()));
176         DHLOGI("codec name: %{public}s, mimeType: %{public}s", coder.c_str(), mimeType.c_str());
177     }
178     cJSON_AddItemToObject(root, CAMERA_CODEC_TYPE_KEY.c_str(), array);
179     char *jsonstr = cJSON_Print(root);
180     if (jsonstr == nullptr) {
181         cJSON_Delete(root);
182         return sourceAttrs;
183     }
184     sourceAttrs = jsonstr;
185     cJSON_free(jsonstr);
186     cJSON_Delete(root);
187     return sourceAttrs;
188 }
189 
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId,const EnableParam & param)190 int32_t DistributedCameraSourceService::RegisterDistributedHardware(const std::string& devId, const std::string& dhId,
191     const std::string& reqId, const EnableParam& param)
192 {
193     DHLOGI("RegisterDistributedHardware devId: %{public}s, dhId: %{public}s, sinkVersion: %{public}s",
194         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), param.sinkVersion.c_str());
195     if (GetCamDevNum() > MAX_CAMERAS_NUMBER) {
196         DHLOGE("cameras exceed the upper limit");
197         return DCAMERA_BAD_VALUE;
198     }
199     EnableParam params = const_cast<EnableParam&>(param);
200     params.sourceAttrs = GetCodecInfo();
201     DHLOGI("RegisterDistributedHardware sourceAttrs: %{public}s.", params.sourceAttrs.c_str());
202     DCameraIndex camIndex(devId, dhId);
203     int32_t ret = DCAMERA_OK;
204     std::shared_ptr<DCameraSourceDev> camDev = GetCamDevByIndex(camIndex);
205     if (camDev == nullptr) {
206         DHLOGI("new dev devId: %{public}s, dhId: %{public}s, sinkVersion: %{public}s",
207             GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), params.sinkVersion.c_str());
208         camDev = std::make_shared<DCameraSourceDev>(devId, dhId, listener_);
209         ret = camDev->InitDCameraSourceDev();
210         if (ret != DCAMERA_OK) {
211             DHLOGE("RegisterDistributedHardware failed %{public}d InitDev devId: %{public}s, dhId: %{public}s",
212                 ret, GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
213             return ret;
214         }
215         CamDevInsert(camIndex, camDev);
216     }
217 
218     ret = camDev->RegisterDistributedHardware(devId, dhId, reqId, params);
219     if (ret != DCAMERA_OK) {
220         DHLOGE("RegisterDistributedHardware failed, ret: %{public}d", ret);
221         ReportRegisterCameraFail(DCAMERA_REGISTER_FAIL, GetAnonyString(devId), dhId, params.sinkVersion,
222             "dcamera source RegisterDistributedHardware fail.");
223         CamDevErase(camIndex);
224     }
225     DHLOGI("RegisterDistributedHardware end devId: %{public}s, dhId: %{public}s, sinkVersion: %{public}s",
226         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), params.sinkVersion.c_str());
227     return ret;
228 }
229 
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId)230 int32_t DistributedCameraSourceService::UnregisterDistributedHardware(const std::string& devId, const std::string& dhId,
231     const std::string& reqId)
232 {
233     DHLOGI("UnregisterDistributedHardware devId: %{public}s, dhId: %{public}s",
234         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
235     DCameraIndex camIndex(devId, dhId);
236     std::shared_ptr<DCameraSourceDev> camDev = GetCamDevByIndex(camIndex);
237     if (camDev == nullptr) {
238         DHLOGE("DistributedCameraSourceService UnregisterDistributedHardware not found device");
239         return DCAMERA_NOT_FOUND;
240     }
241 
242     int32_t ret = camDev->UnRegisterDistributedHardware(devId, dhId, reqId);
243     if (ret != DCAMERA_OK) {
244         DHLOGE("UnregisterDistributedHardware failed, ret: %{public}d", ret);
245     }
246     return ret;
247 }
248 
DCameraNotify(const std::string & devId,const std::string & dhId,std::string & events)249 int32_t DistributedCameraSourceService::DCameraNotify(const std::string& devId, const std::string& dhId,
250     std::string& events)
251 {
252     DHLOGI("DCameraNotify devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
253         GetAnonyString(dhId).c_str());
254     DCameraIndex camIndex(devId, dhId);
255     std::shared_ptr<DCameraSourceDev> camDev = GetCamDevByIndex(camIndex);
256     if (camDev == nullptr) {
257         DHLOGE("DistributedCameraSourceService DCameraNotify not found device");
258         return DCAMERA_NOT_FOUND;
259     }
260 
261     int32_t ret = camDev->DCameraNotify(events);
262     if (ret != DCAMERA_OK) {
263         DHLOGE("DCameraNotify failed, ret: %{public}d", ret);
264     }
265     return ret;
266 }
267 
LoadDCameraHDF()268 int32_t DistributedCameraSourceService::LoadDCameraHDF()
269 {
270     DCAMERA_SYNC_TRACE(DCAMERA_LOAD_HDF);
271     DHLOGI("load hdf driver start");
272     int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl();
273     if (ret != DCAMERA_OK) {
274         DHLOGE("load hdf driver failed, ret %{public}d", ret);
275         ReportDcamerInitFail(DCAMERA_INIT_FAIL, DCAMERA_HDF_ERROR, CreateMsg("dcamera load hdf driver fail."));
276         return ret;
277     }
278     DHLOGI("load hdf driver end");
279     return DCAMERA_OK;
280 }
281 
UnLoadCameraHDF()282 int32_t DistributedCameraSourceService::UnLoadCameraHDF()
283 {
284     DHLOGI("unload hdf driver start");
285     int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl();
286     if (ret != DCAMERA_OK) {
287         DHLOGE("unload hdf driver failed, ret %{public}d", ret);
288         return ret;
289     }
290     DHLOGI("unload hdf driver end");
291     return DCAMERA_OK;
292 }
293 
Dump(int32_t fd,const std::vector<std::u16string> & args)294 int DistributedCameraSourceService::Dump(int32_t fd, const std::vector<std::u16string>& args)
295 {
296     DHLOGI("DistributedCameraSourceService Dump.");
297     if (args.size() > DUMP_MAX_SIZE) {
298         DHLOGE("DistributedCameraSourceService Dump input is invalid");
299         return DCAMERA_BAD_VALUE;
300     }
301     std::string result;
302     std::vector<std::string> argsStr;
303     for (auto item : args) {
304         argsStr.emplace_back(Str16ToStr8(item));
305     }
306 
307     if (!DcameraSourceHidumper::GetInstance().Dump(argsStr, result)) {
308         DHLOGE("Hidump error");
309         return DCAMERA_BAD_VALUE;
310     }
311 
312     int ret = dprintf(fd, "%s\n", result.c_str());
313     if (ret < 0) {
314         DHLOGE("dprintf error");
315         return DCAMERA_BAD_VALUE;
316     }
317 
318     return DCAMERA_OK;
319 }
320 
GetDumpInfo(CameraDumpInfo & camDump)321 void DistributedCameraSourceService::GetDumpInfo(CameraDumpInfo& camDump)
322 {
323     std::lock_guard<std::mutex> camLock(camDevMutex_);
324     camDump.regNumber = static_cast<int32_t>(camerasMap_.size());
325     std::map<std::string, int32_t> curState;
326     for (auto it = camerasMap_.begin(); it != camerasMap_.end(); it++) {
327         DCameraIndex cam = it->first;
328         std::shared_ptr<DCameraSourceDev> camSourceDev = it->second;
329         camDump.version = camSourceDev->GetVersion();
330         std::string deviceId = GetAnonyString(cam.devId_);
331         deviceId.append(cam.dhId_);
332         int32_t devState = camSourceDev->GetStateInfo();
333         curState[deviceId] = devState;
334     }
335     camDump.curState = curState;
336 }
337 
CamDevInsert(DCameraIndex & index,std::shared_ptr<DCameraSourceDev> & camDev)338 void DistributedCameraSourceService::CamDevInsert(DCameraIndex& index, std::shared_ptr<DCameraSourceDev>& camDev)
339 {
340     std::lock_guard<std::mutex> camLock(camDevMutex_);
341     camerasMap_.emplace(index, camDev);
342 }
343 
GetCamDevByIndex(DCameraIndex & index)344 std::shared_ptr<DCameraSourceDev> DistributedCameraSourceService::GetCamDevByIndex(DCameraIndex& index)
345 {
346     std::lock_guard<std::mutex> camLock(camDevMutex_);
347     auto iter = camerasMap_.find(index);
348     if (iter == camerasMap_.end()) {
349         return nullptr;
350     }
351     return iter->second;
352 }
353 
CamDevErase(DCameraIndex & index)354 void DistributedCameraSourceService::CamDevErase(DCameraIndex& index)
355 {
356     std::lock_guard<std::mutex> camLock(camDevMutex_);
357     camerasMap_.erase(index);
358 }
359 
GetCamDevNum()360 uint32_t DistributedCameraSourceService::GetCamDevNum()
361 {
362     std::lock_guard<std::mutex> camLock(camDevMutex_);
363     return camerasMap_.size();
364 }
365 
StartHicollieThread()366 void DistributedCameraSourceService::StartHicollieThread()
367 {
368     auto taskFunc = [this]() {
369         std::lock_guard<std::mutex> lock(camDevMutex_);
370         for (auto &iter : camerasMap_) {
371             if (iter.second->GetHicollieFlag()) {
372                 iter.second->SetHicollieFlag(false);
373             } else {
374                 DHLOGE("Hicollie : Flag = false, exit the current process");
375                 _Exit(0);
376             }
377         }
378     };
379     OHOS::HiviewDFX::Watchdog::GetInstance().RunPeriodicalTask(CAMERA_HICOLLIE, taskFunc,
380         HICOLLIE_INTERVAL_TIME_MS, HICOLLIE_DELAY_TIME_MS);
381 
382     while (isHicollieRunning_.load()) {
383         {
384             std::lock_guard<std::mutex> lock(camDevMutex_);
385             if (!camerasMap_.empty()) {
386                 for (auto &iter : camerasMap_) {
387                     iter.second->PostHicollieEvent();
388                 }
389             }
390         }
391         usleep(HICOLLIE_SLEEP_TIME_US);
392     }
393 }
394 } // namespace DistributedHardware
395 } // namespace OHOS
396