1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "GCH_HidlCameraProvider"
18 //#define LOG_NDEBUG 0
19 #include <log/log.h>
20 #include <regex>
21
22 #include "camera_device.h"
23 #include "hidl_camera_device.h"
24 #include "hidl_camera_provider.h"
25 #include "hidl_utils.h"
26
27 namespace android {
28 namespace hardware {
29 namespace camera {
30 namespace provider {
31 namespace V2_6 {
32 namespace implementation {
33
34 namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;
35
36 using ::android::google_camera_hal::CameraDevice;
37
38 const std::string HidlCameraProvider::kProviderName = "internal";
39 // "device@<version>/internal/<id>"
40 const std::regex HidlCameraProvider::kDeviceNameRegex(
41 "device@([0-9]+\\.[0-9]+)/internal/(.+)");
42
Create()43 std::unique_ptr<HidlCameraProvider> HidlCameraProvider::Create() {
44 auto provider = std::unique_ptr<HidlCameraProvider>(new HidlCameraProvider());
45 if (provider == nullptr) {
46 ALOGE("%s: Cannot create a HidlCameraProvider.", __FUNCTION__);
47 return nullptr;
48 }
49
50 status_t res = provider->Initialize();
51 if (res != OK) {
52 ALOGE("%s: Initializing HidlCameraProvider failed: %s(%d)", __FUNCTION__,
53 strerror(-res), res);
54 return nullptr;
55 }
56
57 return provider;
58 }
59
Initialize()60 status_t HidlCameraProvider::Initialize() {
61 google_camera_provider_ = CameraProvider::Create();
62 if (google_camera_provider_ == nullptr) {
63 ALOGE("%s: Creating CameraProvider failed.", __FUNCTION__);
64 return NO_INIT;
65 }
66
67 camera_provider_callback_ = {
68 .camera_device_status_change = google_camera_hal::CameraDeviceStatusChangeFunc(
69 [this](std::string camera_id,
70 google_camera_hal::CameraDeviceStatus new_status) {
71 if (callbacks_ == nullptr) {
72 ALOGE("%s: callbacks_ is null", __FUNCTION__);
73 return;
74 }
75 CameraDeviceStatus hidl_camera_device_status;
76 status_t res = hidl_utils::ConvertToHidlCameraDeviceStatus(
77 new_status, &hidl_camera_device_status);
78 if (res != OK) {
79 ALOGE(
80 "%s: Converting to hidl camera device status failed: %s(%d)",
81 __FUNCTION__, strerror(-res), res);
82 return;
83 }
84
85 std::unique_lock<std::mutex> lock(callbacks_lock_);
86 callbacks_->cameraDeviceStatusChange(
87 "device@" +
88 device::V3_5::implementation::HidlCameraDevice::kDeviceVersion +
89 "/" + kProviderName + "/" + camera_id,
90 hidl_camera_device_status);
91 }),
92 .physical_camera_device_status_change = google_camera_hal::
93 PhysicalCameraDeviceStatusChangeFunc([this](
94 std::string camera_id,
95 std::string physical_camera_id,
96 google_camera_hal::CameraDeviceStatus
97 new_status) {
98 if (callbacks_ == nullptr) {
99 ALOGE("%s: callbacks_ is null", __FUNCTION__);
100 return;
101 }
102 auto castResult =
103 provider::V2_6::ICameraProviderCallback::castFrom(callbacks_);
104 if (!castResult.isOk()) {
105 ALOGE("%s: callbacks_ cannot be casted to version 2.6",
106 __FUNCTION__);
107 return;
108 }
109 sp<provider::V2_6::ICameraProviderCallback> callbacks_2_6_ =
110 castResult;
111 if (callbacks_2_6_ == nullptr) {
112 ALOGE("%s: callbacks_2_6_ is null", __FUNCTION__);
113 return;
114 }
115
116 CameraDeviceStatus hidl_camera_device_status;
117 status_t res = hidl_utils::ConvertToHidlCameraDeviceStatus(
118 new_status, &hidl_camera_device_status);
119 if (res != OK) {
120 ALOGE(
121 "%s: Converting to hidl camera device status failed: %s(%d)",
122 __FUNCTION__, strerror(-res), res);
123 return;
124 }
125
126 std::unique_lock<std::mutex> lock(callbacks_lock_);
127 callbacks_2_6_->physicalCameraDeviceStatusChange(
128 "device@" +
129 device::V3_5::implementation::HidlCameraDevice::kDeviceVersion +
130 "/" + kProviderName + "/" + camera_id,
131 physical_camera_id, hidl_camera_device_status);
132 }),
133 .torch_mode_status_change = google_camera_hal::TorchModeStatusChangeFunc(
134 [this](std::string camera_id,
135 google_camera_hal::TorchModeStatus new_status) {
136 if (callbacks_ == nullptr) {
137 ALOGE("%s: callbacks_ is null", __FUNCTION__);
138 return;
139 }
140
141 TorchModeStatus hidl_torch_status;
142 status_t res = hidl_utils::ConvertToHidlTorchModeStatus(
143 new_status, &hidl_torch_status);
144 if (res != OK) {
145 ALOGE("%s: Converting to hidl torch status failed: %s(%d)",
146 __FUNCTION__, strerror(-res), res);
147 return;
148 }
149
150 std::unique_lock<std::mutex> lock(callbacks_lock_);
151 callbacks_->torchModeStatusChange(
152 "device@" +
153 device::V3_5::implementation::HidlCameraDevice::kDeviceVersion +
154 "/" + kProviderName + "/" + camera_id,
155 hidl_torch_status);
156 }),
157 };
158
159 google_camera_provider_->SetCallback(&camera_provider_callback_);
160 // purge pending malloc pages after initialization
161 mallopt(M_PURGE, 0);
162 return OK;
163 }
164
setCallback(const sp<ICameraProviderCallback> & callback)165 Return<Status> HidlCameraProvider::setCallback(
166 const sp<ICameraProviderCallback>& callback) {
167 {
168 std::unique_lock<std::mutex> lock(callbacks_lock_);
169 callbacks_ = callback;
170 }
171
172 google_camera_provider_->TriggerDeferredCallbacks();
173
174 return Status::OK;
175 }
176
getVendorTags(getVendorTags_cb _hidl_cb)177 Return<void> HidlCameraProvider::getVendorTags(getVendorTags_cb _hidl_cb) {
178 hidl_vec<VendorTagSection> hidl_vendor_tag_sections;
179 std::vector<google_camera_hal::VendorTagSection> hal_vendor_tag_sections;
180
181 status_t res =
182 google_camera_provider_->GetVendorTags(&hal_vendor_tag_sections);
183 if (res != OK) {
184 ALOGE("%s: Getting vendor tags failed: %s(%d)", __FUNCTION__,
185 strerror(-res), res);
186 _hidl_cb(Status::INTERNAL_ERROR, hidl_vendor_tag_sections);
187 return Void();
188 }
189
190 res = hidl_utils::ConvertToHidlVendorTagSections(hal_vendor_tag_sections,
191 &hidl_vendor_tag_sections);
192 if (res != OK) {
193 ALOGE("%s: Converting to hidl vendor tags failed: %s(%d)", __FUNCTION__,
194 strerror(-res), res);
195 _hidl_cb(Status::INTERNAL_ERROR, hidl_vendor_tag_sections);
196 return Void();
197 }
198
199 _hidl_cb(Status::OK, hidl_vendor_tag_sections);
200 return Void();
201 }
202
getCameraIdList(getCameraIdList_cb _hidl_cb)203 Return<void> HidlCameraProvider::getCameraIdList(getCameraIdList_cb _hidl_cb) {
204 std::vector<uint32_t> camera_ids;
205 hidl_vec<hidl_string> hidl_camera_ids;
206
207 status_t res = google_camera_provider_->GetCameraIdList(&camera_ids);
208 if (res != OK) {
209 ALOGE("%s: Getting camera ID list failed: %s(%d)", __FUNCTION__,
210 strerror(-res), res);
211 _hidl_cb(Status::INTERNAL_ERROR, hidl_camera_ids);
212 return Void();
213 }
214
215 hidl_camera_ids.resize(camera_ids.size());
216 for (uint32_t i = 0; i < hidl_camera_ids.size(); i++) {
217 // camera ID is in the form of "device@<major>.<minor>/<type>/<id>"
218 hidl_camera_ids[i] =
219 "device@" +
220 device::V3_5::implementation::HidlCameraDevice::kDeviceVersion + "/" +
221 kProviderName + "/" + std::to_string(camera_ids[i]);
222 }
223
224 _hidl_cb(Status::OK, hidl_camera_ids);
225 return Void();
226 }
227
getConcurrentStreamingCameraIds(getConcurrentStreamingCameraIds_cb _hidl_cb)228 Return<void> HidlCameraProvider::getConcurrentStreamingCameraIds(
229 getConcurrentStreamingCameraIds_cb _hidl_cb) {
230 hidl_vec<hidl_vec<hidl_string>> hidl_camera_id_combinations;
231 std::vector<std::unordered_set<uint32_t>> camera_id_combinations;
232 status_t res = google_camera_provider_->GetConcurrentStreamingCameraIds(
233 &camera_id_combinations);
234 if (res != OK) {
235 ALOGE(
236 "%s: Getting the combinations of concurrent streaming camera ids "
237 "failed: %s(%d)",
238 __FUNCTION__, strerror(-res), res);
239 _hidl_cb(Status::INTERNAL_ERROR, hidl_camera_id_combinations);
240 return Void();
241 }
242 hidl_camera_id_combinations.resize(camera_id_combinations.size());
243 int i = 0;
244 for (auto& combination : camera_id_combinations) {
245 hidl_vec<hidl_string> hidl_combination(combination.size());
246 int c = 0;
247 for (auto& camera_id : combination) {
248 hidl_combination[c] = std::to_string(camera_id);
249 c++;
250 }
251 hidl_camera_id_combinations[i] = hidl_combination;
252 i++;
253 }
254 _hidl_cb(Status::OK, hidl_camera_id_combinations);
255 return Void();
256 }
257
isConcurrentStreamCombinationSupported(const hidl_vec<CameraIdAndStreamCombination> & configs,isConcurrentStreamCombinationSupported_cb _hidl_cb)258 Return<void> HidlCameraProvider::isConcurrentStreamCombinationSupported(
259 const hidl_vec<CameraIdAndStreamCombination>& configs,
260 isConcurrentStreamCombinationSupported_cb _hidl_cb) {
261 std::vector<google_camera_hal::CameraIdAndStreamConfiguration>
262 devices_stream_configs(configs.size());
263 status_t res = OK;
264 size_t c = 0;
265 for (auto& config : configs) {
266 res = hidl_utils::ConverToHalStreamConfig(
267 config.streamConfiguration,
268 &devices_stream_configs[c].stream_configuration);
269 if (res != OK) {
270 ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
271 _hidl_cb(Status::INTERNAL_ERROR, false);
272 return Void();
273 }
274 uint32_t camera_id = atoi(config.cameraId.c_str());
275 devices_stream_configs[c].camera_id = camera_id;
276 c++;
277 }
278 bool is_supported = false;
279 res = google_camera_provider_->IsConcurrentStreamCombinationSupported(
280 devices_stream_configs, &is_supported);
281 if (res != OK) {
282 ALOGE("%s: ConverToHalStreamConfig failed", __FUNCTION__);
283 _hidl_cb(Status::INTERNAL_ERROR, false);
284 return Void();
285 }
286 _hidl_cb(Status::OK, is_supported);
287 return Void();
288 }
289
isSetTorchModeSupported(isSetTorchModeSupported_cb _hidl_cb)290 Return<void> HidlCameraProvider::isSetTorchModeSupported(
291 isSetTorchModeSupported_cb _hidl_cb) {
292 bool is_supported = google_camera_provider_->IsSetTorchModeSupported();
293 _hidl_cb(Status::OK, is_supported);
294 return Void();
295 }
296
getCameraDeviceInterface_V1_x(const hidl_string &,getCameraDeviceInterface_V1_x_cb _hidl_cb)297 Return<void> HidlCameraProvider::getCameraDeviceInterface_V1_x(
298 const hidl_string& /*cameraDeviceName*/,
299 getCameraDeviceInterface_V1_x_cb _hidl_cb) {
300 _hidl_cb(Status::OPERATION_NOT_SUPPORTED, nullptr);
301 return Void();
302 }
303
ParseDeviceName(const hidl_string & device_name,std::string * device_version,std::string * camera_id)304 bool HidlCameraProvider::ParseDeviceName(const hidl_string& device_name,
305 std::string* device_version,
306 std::string* camera_id) {
307 std::string device_name_std(device_name.c_str());
308 std::smatch sm;
309
310 if (std::regex_match(device_name_std, sm,
311 HidlCameraProvider::kDeviceNameRegex)) {
312 if (device_version != nullptr) {
313 *device_version = sm[1];
314 }
315 if (camera_id != nullptr) {
316 *camera_id = sm[2];
317 }
318 return true;
319 }
320 return false;
321 }
322
getCameraDeviceInterface_V3_x(const hidl_string & camera_device_name,getCameraDeviceInterface_V3_x_cb _hidl_cb)323 Return<void> HidlCameraProvider::getCameraDeviceInterface_V3_x(
324 const hidl_string& camera_device_name,
325 getCameraDeviceInterface_V3_x_cb _hidl_cb) {
326 std::unique_ptr<CameraDevice> google_camera_device;
327
328 // Parse camera_device_name.
329 std::string camera_id, device_version;
330
331 bool match = ParseDeviceName(camera_device_name, &device_version, &camera_id);
332 if (!match) {
333 ALOGE("%s: Device name parse fail. ", __FUNCTION__);
334 _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
335 return Void();
336 }
337
338 status_t res = google_camera_provider_->CreateCameraDevice(
339 atoi(camera_id.c_str()), &google_camera_device);
340 if (res != OK) {
341 ALOGE("%s: Creating CameraDevice failed: %s(%d)", __FUNCTION__,
342 strerror(-res), res);
343 _hidl_cb(hidl_utils::ConvertToHidlStatus(res), nullptr);
344 return Void();
345 }
346
347 auto hidl_camera_device =
348 device::V3_5::implementation::HidlCameraDevice::Create(
349 std::move(google_camera_device));
350 if (hidl_camera_device == nullptr) {
351 ALOGE("%s: Creating HidlCameraDevice failed", __FUNCTION__);
352 _hidl_cb(Status::INTERNAL_ERROR, nullptr);
353 return Void();
354 }
355
356 _hidl_cb(Status::OK, hidl_camera_device.release());
357 return Void();
358 }
359
notifyDeviceStateChange(hardware::hidl_bitfield<DeviceState>)360 Return<void> HidlCameraProvider::notifyDeviceStateChange(
361 hardware::hidl_bitfield<DeviceState> /*newState*/) {
362 return Void();
363 }
364
HIDL_FETCH_ICameraProvider(const char * name)365 ICameraProvider* HIDL_FETCH_ICameraProvider(const char* name) {
366 std::string provider_name = HidlCameraProvider::kProviderName + "/0";
367 if (provider_name.compare(name) != 0) {
368 ALOGE("%s: Unknown provider name: %s", __FUNCTION__, name);
369 return nullptr;
370 }
371
372 auto provider = HidlCameraProvider::Create();
373 if (provider == nullptr) {
374 ALOGE("%s: Cannot create a HidlCameraProvider.", __FUNCTION__);
375 return nullptr;
376 }
377
378 return provider.release();
379 }
380
381 } // namespace implementation
382 } // namespace V2_6
383 } // namespace provider
384 } // namespace camera
385 } // namespace hardware
386 } // namespace android
387