1 /*
2 * Copyright (c) 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_hdf_operate.h"
17
18 #include <hdf_io_service_if.h>
19
20 #include "anonymous_string.h"
21 #include "distributed_camera_errno.h"
22 #include "distributed_hardware_log.h"
23
24 namespace OHOS {
25 namespace DistributedHardware {
26 IMPLEMENT_SINGLE_INSTANCE(DCameraHdfOperate);
27
OnReceive(const ServiceStatus & status)28 void DCameraHdfServStatListener::OnReceive(const ServiceStatus& status)
29 {
30 DHLOGI("service status on receive");
31 if (status.serviceName == CAMERA_SERVICE_NAME || status.serviceName == PROVIDER_SERVICE_NAME) {
32 callback_(status);
33 }
34 }
35
LoadDcameraHDFImpl()36 int32_t DCameraHdfOperate::LoadDcameraHDFImpl()
37 {
38 if (cameraServStatus_ == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START &&
39 providerServStatus_ == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
40 DHLOGI("service has already start");
41 return DCAMERA_OK;
42 }
43 servMgr_ = IServiceManager::Get();
44 devmgr_ = IDeviceManager::Get();
45 if (servMgr_ == nullptr || devmgr_ == nullptr) {
46 DHLOGE("get hdi service manager or device manager failed!");
47 return DCAMERA_BAD_VALUE;
48 }
49
50 ::OHOS::sptr<IServStatListener> listener =
51 new DCameraHdfServStatListener(DCameraHdfServStatListener::StatusCallback([&](const ServiceStatus& status) {
52 DHLOGI("LoadCameraService service status callback, serviceName: %s, status: %d",
53 status.serviceName.c_str(), status.status);
54 std::unique_lock<std::mutex> lock(hdfOperateMutex_);
55 if (status.serviceName == CAMERA_SERVICE_NAME) {
56 cameraServStatus_ = status.status;
57 hdfOperateCon_.notify_one();
58 } else if (status.serviceName == PROVIDER_SERVICE_NAME) {
59 providerServStatus_ = status.status;
60 hdfOperateCon_.notify_one();
61 }
62 }));
63 if (servMgr_->RegisterServiceStatusListener(listener, DEVICE_CLASS_CAMERA) != 0) {
64 DHLOGE("RegisterServiceStatusListener failed!");
65 return DCAMERA_BAD_VALUE;
66 }
67
68 DHLOGI("Load camera service.");
69 if (devmgr_->LoadDevice(CAMERA_SERVICE_NAME) != 0) {
70 DHLOGE("Load camera service failed!");
71 return DCAMERA_BAD_OPERATE;
72 }
73 if (WaitLoadCameraService() != DCAMERA_OK) {
74 return DCAMERA_BAD_OPERATE;
75 }
76
77 DHLOGI("Load provider service.");
78 if (devmgr_->LoadDevice(PROVIDER_SERVICE_NAME) != 0) {
79 DHLOGE("Load provider service failed!");
80 return DCAMERA_BAD_OPERATE;
81 }
82 if (WaitLoadProviderService() != DCAMERA_OK) {
83 return DCAMERA_BAD_OPERATE;
84 }
85
86 if (servMgr_->UnregisterServiceStatusListener(listener) != 0) {
87 DHLOGE("UnregisterServiceStatusListener failed!");
88 }
89 return DCAMERA_OK;
90 }
91
WaitLoadCameraService()92 int32_t DCameraHdfOperate::WaitLoadCameraService()
93 {
94 DHLOGI("wait Load camera service.");
95 std::unique_lock<std::mutex> lock(hdfOperateMutex_);
96 hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(WAIT_TIME), [this] {
97 return (this->cameraServStatus_ == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
98 });
99
100 if (cameraServStatus_ != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
101 DHLOGE("wait load cameraService failed, status %d", cameraServStatus_);
102 return DCAMERA_BAD_OPERATE;
103 }
104
105 return DCAMERA_OK;
106 }
107
WaitLoadProviderService()108 int32_t DCameraHdfOperate::WaitLoadProviderService()
109 {
110 DHLOGI("wait Load provider service.");
111 std::unique_lock<std::mutex> lock(hdfOperateMutex_);
112 hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(WAIT_TIME), [this] {
113 return (this->providerServStatus_ == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
114 });
115
116 if (providerServStatus_ != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
117 DHLOGE("wait load providerService failed, status %d", providerServStatus_);
118 return DCAMERA_BAD_OPERATE;
119 }
120
121 return DCAMERA_OK;
122 }
123
UnLoadDcameraHDFImpl()124 int32_t DCameraHdfOperate::UnLoadDcameraHDFImpl()
125 {
126 DHLOGI("UnLoadCameraHDFImpl begin!");
127 devmgr_ = IDeviceManager::Get();
128 if (devmgr_ == nullptr) {
129 DHLOGE("get hdi device manager failed!");
130 return DCAMERA_BAD_VALUE;
131 }
132
133 int32_t ret = devmgr_->UnloadDevice(CAMERA_SERVICE_NAME);
134 if (ret != 0) {
135 DHLOGE("Unload camera service failed, ret: %d", ret);
136 }
137 ret = devmgr_->UnloadDevice(PROVIDER_SERVICE_NAME);
138 if (ret != 0) {
139 DHLOGE("Unload provider service failed, ret: %d", ret);
140 }
141 cameraServStatus_ = INVALID_VALUE;
142 providerServStatus_ = INVALID_VALUE;
143 DHLOGI("UnLoadCameraHDFImpl end!");
144 return DCAMERA_OK;
145 }
146 } // namespace DistributedHardware
147 } // namespace OHOS