blob: f44fd08384443077b17414e3ef5104a67d3cd7a7 [file] [log] [blame]
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001/*
2 * Copyright (C) 2016 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 "CameraProviderManager"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include "CameraProviderManager.h"
22
Yin-Chia Yeh65405092017-01-13 15:42:28 -080023#include <chrono>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080024#include <android/hidl/manager/1.0/IServiceManager.h>
25#include <hidl/ServiceManagement.h>
26
27namespace android {
28
29using namespace ::android::hardware::camera;
30using namespace ::android::hardware::camera::common::V1_0;
31
32namespace {
33// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
34// service manager
35const std::string kLegacyProviderName("legacy/0");
36
37// Slash-separated list of provider types to consider for use via the old camera API
38const std::string kStandardProviderTypes("internal/legacy");
39
40} // anonymous namespace
41
42CameraProviderManager::HardwareServiceInteractionProxy
43CameraProviderManager::sHardwareServiceInteractionProxy{};
44
45CameraProviderManager::~CameraProviderManager() {
46}
47
48status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
49 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080050 std::lock_guard<std::mutex> lock(mInterfaceMutex);
51 if (proxy == nullptr) {
52 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
53 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080054 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080055 mListener = listener;
56 mServiceProxy = proxy;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080057
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080058 // Registering will trigger notifications for all already-known providers
59 bool success = mServiceProxy->registerForNotifications(
60 /* instance name, empty means no filter */ "",
61 this);
62 if (!success) {
63 ALOGE("%s: Unable to register with hardware service manager for notifications "
64 "about camera providers", __FUNCTION__);
65 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080066 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080067 // See if there's a passthrough HAL, but let's not complain if there's not
68 addProvider(kLegacyProviderName, /*expected*/ false);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080069 return OK;
70}
71
72int CameraProviderManager::getCameraCount() const {
73 std::lock_guard<std::mutex> lock(mInterfaceMutex);
74 int count = 0;
75 for (auto& provider : mProviders) {
76 count += provider->mDevices.size();
77 }
78 return count;
79}
80
81int CameraProviderManager::getStandardCameraCount() const {
82 std::lock_guard<std::mutex> lock(mInterfaceMutex);
83 int count = 0;
84 for (auto& provider : mProviders) {
85 if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) {
86 count += provider->mDevices.size();
87 }
88 }
89 return count;
90}
91
92std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
93 std::lock_guard<std::mutex> lock(mInterfaceMutex);
94 std::vector<std::string> deviceIds;
95 for (auto& provider : mProviders) {
96 for (auto& deviceInfo : provider->mDevices) {
97 deviceIds.push_back(deviceInfo->mId);
98 }
99 }
100 return deviceIds;
101}
102
103bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
104 std::lock_guard<std::mutex> lock(mInterfaceMutex);
105 return isValidDeviceLocked(id, majorVersion);
106}
107
108bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
109 for (auto& provider : mProviders) {
110 for (auto& deviceInfo : provider->mDevices) {
111 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
112 return true;
113 }
114 }
115 }
116 return false;
117}
118
119bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
120 std::lock_guard<std::mutex> lock(mInterfaceMutex);
121
122 auto deviceInfo = findDeviceInfoLocked(id);
123 if (deviceInfo == nullptr) return false;
124
125 return deviceInfo->hasFlashUnit();
126}
127
128status_t CameraProviderManager::getResourceCost(const std::string &id,
129 CameraResourceCost* cost) const {
130 std::lock_guard<std::mutex> lock(mInterfaceMutex);
131
132 auto deviceInfo = findDeviceInfoLocked(id);
133 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
134
135 *cost = deviceInfo->mResourceCost;
136 return OK;
137}
138
139status_t CameraProviderManager::getCameraInfo(const std::string &id,
140 hardware::CameraInfo* info) const {
141 std::lock_guard<std::mutex> lock(mInterfaceMutex);
142
143 auto deviceInfo = findDeviceInfoLocked(id);
144 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
145
146 return deviceInfo->getCameraInfo(info);
147}
148
149status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
150 CameraMetadata* characteristics) const {
151 std::lock_guard<std::mutex> lock(mInterfaceMutex);
152
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800153 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800154 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
155
156 return deviceInfo->getCameraCharacteristics(characteristics);
157}
158
159status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
160 hardware::hidl_version *v) {
161 std::lock_guard<std::mutex> lock(mInterfaceMutex);
162
163 hardware::hidl_version maxVersion{0,0};
164 bool found = false;
165 for (auto& provider : mProviders) {
166 for (auto& deviceInfo : provider->mDevices) {
167 if (deviceInfo->mId == id) {
168 if (deviceInfo->mVersion > maxVersion) {
169 maxVersion = deviceInfo->mVersion;
170 found = true;
171 }
172 }
173 }
174 }
175 if (!found) {
176 return NAME_NOT_FOUND;
177 }
178 *v = maxVersion;
179 return OK;
180}
181
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800182status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
183 std::lock_guard<std::mutex> lock(mInterfaceMutex);
184
185 auto deviceInfo = findDeviceInfoLocked(id);
186 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
187
188 return deviceInfo->setTorchMode(enabled);
189}
190
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800191status_t CameraProviderManager::setUpVendorTags() {
192 // TODO (b/34275821): support aggregating vendor tags for more than one provider
193 for (auto& provider : mProviders) {
194 hardware::hidl_vec<VendorTagSection> vts;
195 Status status;
196 provider->mInterface->getVendorTags(
197 [&](auto s, const auto& vendorTagSecs) {
198 status = s;
199 if (s == Status::OK) {
200 vts = vendorTagSecs;
201 }
202 });
203
204 if (status != Status::OK) {
205 return mapToStatusT(status);
206 }
207
208 VendorTagDescriptor::clearGlobalVendorTagDescriptor();
209
210 // Read all vendor tag definitions into a descriptor
211 sp<VendorTagDescriptor> desc;
212 status_t res;
213 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/desc))
214 != OK) {
215 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
216 "received error %s (%d). Camera clients will not be able to use"
217 "vendor tags", __FUNCTION__, strerror(res), res);
218 return res;
219 }
220
221 // Set the global descriptor to use with camera metadata
222 VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
223 }
224 return OK;
225}
226
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800227status_t CameraProviderManager::openSession(const std::string &id,
228 const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
229 /*out*/
230 sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {
231
232 std::lock_guard<std::mutex> lock(mInterfaceMutex);
233
234 auto deviceInfo = findDeviceInfoLocked(id,
235 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
236 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
237
238 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
239
240 Status status;
241 deviceInfo3->mInterface->open(callback, [&status, &session]
242 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
243 status = s;
244 if (status == Status::OK) {
245 *session = cameraSession;
246 }
247 });
248 return mapToStatusT(status);
249}
250
251status_t CameraProviderManager::openSession(const std::string &id,
252 const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
253 /*out*/
254 sp<hardware::camera::device::V1_0::ICameraDevice> *session) {
255
256 std::lock_guard<std::mutex> lock(mInterfaceMutex);
257
258 auto deviceInfo = findDeviceInfoLocked(id,
259 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
260 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
261
262 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
263
264 Status status = deviceInfo1->mInterface->open(callback);
265 if (status == Status::OK) {
266 *session = deviceInfo1->mInterface;
267 }
268 return mapToStatusT(status);
269}
270
271
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800272hardware::Return<void> CameraProviderManager::onRegistration(
273 const hardware::hidl_string& /*fqName*/,
274 const hardware::hidl_string& name,
275 bool /*preexisting*/) {
276 std::lock_guard<std::mutex> lock(mInterfaceMutex);
277
278 addProvider(name);
279 return hardware::Return<void>();
280}
281
282status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
283 std::lock_guard<std::mutex> lock(mInterfaceMutex);
284
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800285 for (auto& provider : mProviders) {
286 provider->dump(fd, args);
287 }
288 return OK;
289}
290
291CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800292 const std::string& id,
293 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800294 for (auto& provider : mProviders) {
295 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800296 if (deviceInfo->mId == id &&
297 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800298 return deviceInfo.get();
299 }
300 }
301 }
302 return nullptr;
303}
304
305
306status_t CameraProviderManager::addProvider(const std::string& newProvider, bool expected) {
307 for (const auto& providerInfo : mProviders) {
308 if (providerInfo->mProviderName == newProvider) {
309 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
310 newProvider.c_str());
311 return ALREADY_EXISTS;
312 }
313 }
314 sp<provider::V2_4::ICameraProvider> interface =
315 mServiceProxy->getService(newProvider);
316
317 if (interface == nullptr) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -0800318 ALOGW("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
319 newProvider.c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800320 if (expected) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800321 return BAD_VALUE;
322 } else {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800323 return OK;
324 }
325 }
326
327 sp<ProviderInfo> providerInfo =
328 new ProviderInfo(newProvider, interface, this);
329 status_t res = providerInfo->initialize();
330 if (res != OK) {
331 return res;
332 }
333
334 mProviders.push_back(providerInfo);
335
336 return OK;
337}
338
339status_t CameraProviderManager::removeProvider(const std::string& provider) {
340 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
341 if ((*it)->mProviderName == provider) {
342 mProviders.erase(it);
343 return OK;
344 }
345 }
346 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
347 provider.c_str());
348 return NAME_NOT_FOUND;
349}
350
351/**** Methods for ProviderInfo ****/
352
353
354CameraProviderManager::ProviderInfo::ProviderInfo(
355 const std::string &providerName,
356 sp<provider::V2_4::ICameraProvider>& interface,
357 CameraProviderManager *manager) :
358 mProviderName(providerName),
359 mInterface(interface),
360 mManager(manager) {
361 (void) mManager;
362}
363
364status_t CameraProviderManager::ProviderInfo::initialize() {
365 status_t res = parseProviderName(mProviderName, &mType, &mId);
366 if (res != OK) {
367 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
368 return BAD_VALUE;
369 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -0800370 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
371 mProviderName.c_str(), mInterface->isRemote());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800372 Status status = mInterface->setCallback(this);
373 if (status != Status::OK) {
374 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
375 __FUNCTION__, mProviderName.c_str());
376 return mapToStatusT(status);
377 }
378 // TODO: Register for hw binder death notifications as well
379
380 // Get initial list of camera devices, if any
381 std::vector<std::string> devices;
382 mInterface->getCameraIdList([&status, &devices](
383 Status idStatus,
384 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
385 status = idStatus;
386 if (status == Status::OK) {
387 for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
388 devices.push_back(cameraDeviceNames[i]);
389 }
390 } });
391
392 if (status != Status::OK) {
393 ALOGE("%s: Unable to query for camera devices from provider '%s'",
394 __FUNCTION__, mProviderName.c_str());
395 return mapToStatusT(status);
396 }
397
398 for (auto& device : devices) {
399 status_t res = addDevice(device);
400 if (res != OK) {
401 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
402 __FUNCTION__, device.c_str(), strerror(-res), res);
403 }
404 }
405
406 ALOGI("Camera provider %s ready with %zu camera devices",
407 mProviderName.c_str(), mDevices.size());
408
409 return OK;
410}
411
412const std::string& CameraProviderManager::ProviderInfo::getType() const {
413 return mType;
414}
415
416status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
417 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
418
419 ALOGI("Enumerating new camera device: %s", name.c_str());
420
421 uint16_t major, minor;
422 std::string type, id;
423
424 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
425 if (res != OK) {
426 return res;
427 }
428 if (type != mType) {
429 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
430 type.c_str(), mType.c_str());
431 return BAD_VALUE;
432 }
433 if (mManager->isValidDeviceLocked(id, major)) {
434 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
435 name.c_str(), id.c_str(), major);
436 return BAD_VALUE;
437 }
438
439 std::unique_ptr<DeviceInfo> deviceInfo;
440 switch (major) {
441 case 1:
442 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, id, minor);
443 break;
444 case 3:
445 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, id, minor);
446 break;
447 default:
448 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
449 name.c_str(), major);
450 return BAD_VALUE;
451 }
452 if (deviceInfo == nullptr) return BAD_VALUE;
453 deviceInfo->mStatus = initialStatus;
454
455 mDevices.push_back(std::move(deviceInfo));
456
457 if (parsedId != nullptr) {
458 *parsedId = id;
459 }
460 return OK;
461}
462
463status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800464 dprintf(fd, "== Camera Provider HAL %s (v2.4) static info: %zu devices: ==\n",
465 mProviderName.c_str(), mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800466
467 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800468 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
469 device->mVersion.get_major(), device->mVersion.get_minor());
470 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
471 if (device->mResourceCost.conflictingDevices.size() == 0) {
472 dprintf(fd, " Conflicting devices: None\n");
473 } else {
474 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800475 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800476 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800477 device->mResourceCost.conflictingDevices[i].c_str());
478 }
479 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800480 dprintf(fd, " API1 info:\n");
481 dprintf(fd, " Has a flash unit: %s\n",
482 device->hasFlashUnit() ? "true" : "false");
483 hardware::CameraInfo info;
484 status_t res = device->getCameraInfo(&info);
485 if (res != OK) {
486 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
487 strerror(-res), res);
488 } else {
489 dprintf(fd, " Facing: %s\n",
490 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
491 dprintf(fd, " Orientation: %d\n", info.orientation);
492 }
493 CameraMetadata info2;
494 res = device->getCameraCharacteristics(&info2);
495 if (res == INVALID_OPERATION) {
496 dprintf(fd, " API2 not directly supported\n");
497 } else if (res != OK) {
498 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
499 strerror(-res), res);
500 } else {
501 dprintf(fd, " API2 camera characteristics:\n");
502 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
503 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800504 }
505 return OK;
506}
507
508hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
509 const hardware::hidl_string& cameraDeviceName,
510 CameraDeviceStatus newStatus) {
511 sp<StatusListener> listener;
512 std::string id;
513 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -0800514 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800515 bool known = false;
516 for (auto& deviceInfo : mDevices) {
517 if (deviceInfo->mName == cameraDeviceName) {
518 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
519 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
520 deviceInfo->mStatus = newStatus;
521 // TODO: Handle device removal (NOT_PRESENT)
522 id = deviceInfo->mId;
523 known = true;
524 break;
525 }
526 }
527 // Previously unseen device; status must not be NOT_PRESENT
528 if (!known) {
529 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
530 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
531 mProviderName.c_str(), cameraDeviceName.c_str());
532 return hardware::Void();
533 }
534 addDevice(cameraDeviceName, newStatus, &id);
535 }
536 listener = mManager->mListener.promote();
537 }
538 // Call without lock held to allow reentrancy into provider manager
539 if (listener != nullptr) {
540 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
541 }
542 return hardware::Void();
543}
544
545hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
546 const hardware::hidl_string& cameraDeviceName,
547 TorchModeStatus newStatus) {
548 sp<StatusListener> listener;
549 std::string id;
550 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -0800551 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800552 bool known = false;
553 for (auto& deviceInfo : mDevices) {
554 if (deviceInfo->mName == cameraDeviceName) {
555 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
556 torchStatusToString(newStatus));
557 id = deviceInfo->mId;
558 known = true;
559 break;
560 }
561 }
562 if (!known) {
563 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
564 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
565 return hardware::Void();
566 }
567 listener = mManager->mListener.promote();
568 }
569 // Call without lock held to allow reentrancy into provider manager
570 if (listener != nullptr) {
571 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
572 }
573 return hardware::Void();
574}
575
576
577template<class DeviceInfoT>
578std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
579 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
580 const std::string &name,
581 const std::string &id, uint16_t minorVersion) const {
582 Status status;
583
584 auto cameraInterface =
585 getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
586 if (cameraInterface == nullptr) return nullptr;
587
588 CameraResourceCost resourceCost;
589 cameraInterface->getResourceCost([&status, &resourceCost](
590 Status s, CameraResourceCost cost) {
591 status = s;
592 resourceCost = cost;
593 });
594 if (status != Status::OK) {
595 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
596 name.c_str(), statusToString(status));
597 return nullptr;
598 }
599 return std::unique_ptr<DeviceInfo>(
600 new DeviceInfoT(name, id, minorVersion, resourceCost, cameraInterface));
601}
602
603template<class InterfaceT>
604sp<InterfaceT>
605CameraProviderManager::ProviderInfo::getDeviceInterface(const std::string &name) const {
606 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
607 name.c_str(), InterfaceT::version.get_major());
608 return nullptr;
609}
610
611template<>
612sp<device::V1_0::ICameraDevice>
613CameraProviderManager::ProviderInfo::getDeviceInterface
614 <device::V1_0::ICameraDevice>(const std::string &name) const {
615 Status status;
616 sp<device::V1_0::ICameraDevice> cameraInterface;
617 mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
618 Status s, sp<device::V1_0::ICameraDevice> interface) {
619 status = s;
620 cameraInterface = interface;
621 });
622 if (status != Status::OK) {
623 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
624 name.c_str(), statusToString(status));
625 return nullptr;
626 }
627 return cameraInterface;
628}
629
630template<>
631sp<device::V3_2::ICameraDevice>
632CameraProviderManager::ProviderInfo::getDeviceInterface
633 <device::V3_2::ICameraDevice>(const std::string &name) const {
634 Status status;
635 sp<device::V3_2::ICameraDevice> cameraInterface;
636 mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
637 Status s, sp<device::V3_2::ICameraDevice> interface) {
638 status = s;
639 cameraInterface = interface;
640 });
641 if (status != Status::OK) {
642 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
643 name.c_str(), statusToString(status));
644 return nullptr;
645 }
646 return cameraInterface;
647}
648
649CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
650
651template<class InterfaceT>
652status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
653 bool enabled) {
654 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
655 return mapToStatusT(s);
656}
657
658CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
659 const std::string &id,
660 uint16_t minorVersion,
661 const CameraResourceCost& resourceCost,
662 sp<InterfaceT> interface) :
663 DeviceInfo(name, id, hardware::hidl_version{1, minorVersion}, resourceCost),
664 mInterface(interface) {
665 // Get default parameters and initialize flash unit availability
666 // Requires powering on the camera device
667 Status status = mInterface->open(nullptr);
668 if (status != Status::OK) {
669 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s (%d)", __FUNCTION__,
670 mId.c_str(), CameraProviderManager::statusToString(status), status);
671 return;
672 }
673 mInterface->getParameters([this](const hardware::hidl_string& parms) {
674 mDefaultParameters.unflatten(String8(parms.c_str()));
675 });
676
677 const char *flashMode =
678 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
679 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
680 mHasFlashUnit = true;
681 } else {
682 mHasFlashUnit = false;
683 }
684
685 mInterface->close();
686}
687
688CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
689
690status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
691 return DeviceInfo::setTorchMode(mInterface, enabled);
692}
693
694status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
695 hardware::CameraInfo *info) const {
696 if (info == nullptr) return BAD_VALUE;
697
698 Status status;
699 device::V1_0::CameraInfo cInfo;
700 mInterface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
701 status = s;
702 cInfo = camInfo;
703 });
704 if (status != Status::OK) {
705 return mapToStatusT(status);
706 }
707
708 switch(cInfo.facing) {
709 case device::V1_0::CameraFacing::BACK:
710 info->facing = hardware::CAMERA_FACING_BACK;
711 break;
712 case device::V1_0::CameraFacing::EXTERNAL:
713 // Map external to front for legacy API
714 case device::V1_0::CameraFacing::FRONT:
715 info->facing = hardware::CAMERA_FACING_FRONT;
716 break;
717 default:
718 ALOGW("%s: Unknown camera facing: %d", __FUNCTION__, cInfo.facing);
719 info->facing = hardware::CAMERA_FACING_BACK;
720 }
721 info->orientation = cInfo.orientation;
722
723 return OK;
724}
725
726CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
727 const std::string &id,
728 uint16_t minorVersion,
729 const CameraResourceCost& resourceCost,
730 sp<InterfaceT> interface) :
731 DeviceInfo(name, id, hardware::hidl_version{3, minorVersion}, resourceCost),
732 mInterface(interface) {
733 // Get camera characteristics and initialize flash unit availability
734 Status status;
735 mInterface->getCameraCharacteristics([&status, this](Status s,
736 device::V3_2::CameraMetadata metadata) {
737 status = s;
738 if (s == Status::OK) {
739 camera_metadata_t *buffer =
740 reinterpret_cast<camera_metadata_t*>(metadata.data());
741 mCameraCharacteristics = buffer;
742 }
743 });
744 if (status != Status::OK) {
745 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
746 __FUNCTION__, mId.c_str(), CameraProviderManager::statusToString(status), status);
747 return;
748 }
749 camera_metadata_entry flashAvailable =
750 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
751 if (flashAvailable.count == 1 &&
752 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
753 mHasFlashUnit = true;
754 } else {
755 mHasFlashUnit = false;
756 }
757}
758
759CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
760
761status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
762 return DeviceInfo::setTorchMode(mInterface, enabled);
763}
764
765status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
766 hardware::CameraInfo *info) const {
767 if (info == nullptr) return BAD_VALUE;
768
769 camera_metadata_ro_entry facing =
770 mCameraCharacteristics.find(ANDROID_LENS_FACING);
771 if (facing.count == 1) {
772 switch (facing.data.u8[0]) {
773 case ANDROID_LENS_FACING_BACK:
774 info->facing = hardware::CAMERA_FACING_BACK;
775 break;
776 case ANDROID_LENS_FACING_EXTERNAL:
777 // Map external to front for legacy API
778 case ANDROID_LENS_FACING_FRONT:
779 info->facing = hardware::CAMERA_FACING_FRONT;
780 break;
781 }
782 } else {
783 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
784 return NAME_NOT_FOUND;
785 }
786
787 camera_metadata_ro_entry orientation =
788 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
789 if (orientation.count == 1) {
790 info->orientation = orientation.data.i32[0];
791 } else {
792 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
793 return NAME_NOT_FOUND;
794 }
795
796 return OK;
797}
798
799status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
800 CameraMetadata *characteristics) const {
801 if (characteristics == nullptr) return BAD_VALUE;
802
803 *characteristics = mCameraCharacteristics;
804 return OK;
805}
806
807status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
808 std::string *type, uint32_t *id) {
809 // Format must be "<type>/<id>"
810#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
811 "Should match '<type>/<id>' - "
812
813 if (!type || !id) return INVALID_OPERATION;
814
815 std::string::size_type slashIdx = name.find('/');
816 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
817 ALOGE(ERROR_MSG_PREFIX
818 "does not have / separator between type and id",
819 __FUNCTION__, name.c_str());
820 return BAD_VALUE;
821 }
822
823 std::string typeVal = name.substr(0, slashIdx);
824
825 char *endPtr;
826 errno = 0;
827 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
828 if (errno != 0) {
829 ALOGE(ERROR_MSG_PREFIX
830 "cannot parse provider id as an integer: %s (%d)",
831 __FUNCTION__, name.c_str(), strerror(errno), errno);
832 return BAD_VALUE;
833 }
834 if (endPtr != name.c_str() + name.size()) {
835 ALOGE(ERROR_MSG_PREFIX
836 "provider id has unexpected length",
837 __FUNCTION__, name.c_str());
838 return BAD_VALUE;
839 }
840 if (idVal < 0) {
841 ALOGE(ERROR_MSG_PREFIX
842 "id is negative: %ld",
843 __FUNCTION__, name.c_str(), idVal);
844 return BAD_VALUE;
845 }
846
847#undef ERROR_MSG_PREFIX
848
849 *type = typeVal;
850 *id = static_cast<uint32_t>(idVal);
851
852 return OK;
853}
854
855status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
856 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
857
858 // Format must be "device@<major>.<minor>/<type>/<id>"
859
860#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
861 "Should match 'device@<major>.<minor>/<type>/<id>' - "
862
863 if (!major || !minor || !type || !id) return INVALID_OPERATION;
864
865 // Verify starting prefix
866 const char expectedPrefix[] = "device@";
867
868 if (name.find(expectedPrefix) != 0) {
869 ALOGE(ERROR_MSG_PREFIX
870 "does not start with '%s'",
871 __FUNCTION__, name.c_str(), expectedPrefix);
872 return BAD_VALUE;
873 }
874
875 // Extract major/minor versions
876 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
877 std::string::size_type dotIdx = name.find('.', atIdx);
878 if (dotIdx == std::string::npos) {
879 ALOGE(ERROR_MSG_PREFIX
880 "does not have @<major>. version section",
881 __FUNCTION__, name.c_str());
882 return BAD_VALUE;
883 }
884 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
885 if (typeSlashIdx == std::string::npos) {
886 ALOGE(ERROR_MSG_PREFIX
887 "does not have .<minor>/ version section",
888 __FUNCTION__, name.c_str());
889 return BAD_VALUE;
890 }
891
892 char *endPtr;
893 errno = 0;
894 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
895 if (errno != 0) {
896 ALOGE(ERROR_MSG_PREFIX
897 "cannot parse major version: %s (%d)",
898 __FUNCTION__, name.c_str(), strerror(errno), errno);
899 return BAD_VALUE;
900 }
901 if (endPtr != name.c_str() + dotIdx) {
902 ALOGE(ERROR_MSG_PREFIX
903 "major version has unexpected length",
904 __FUNCTION__, name.c_str());
905 return BAD_VALUE;
906 }
907 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
908 if (errno != 0) {
909 ALOGE(ERROR_MSG_PREFIX
910 "cannot parse minor version: %s (%d)",
911 __FUNCTION__, name.c_str(), strerror(errno), errno);
912 return BAD_VALUE;
913 }
914 if (endPtr != name.c_str() + typeSlashIdx) {
915 ALOGE(ERROR_MSG_PREFIX
916 "minor version has unexpected length",
917 __FUNCTION__, name.c_str());
918 return BAD_VALUE;
919 }
920 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
921 ALOGE(ERROR_MSG_PREFIX
922 "major/minor version is out of range of uint16_t: %ld.%ld",
923 __FUNCTION__, name.c_str(), majorVal, minorVal);
924 return BAD_VALUE;
925 }
926
927 // Extract type and id
928
929 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
930 if (instanceSlashIdx == std::string::npos) {
931 ALOGE(ERROR_MSG_PREFIX
932 "does not have /<type>/ component",
933 __FUNCTION__, name.c_str());
934 return BAD_VALUE;
935 }
936 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
937
938 if (instanceSlashIdx == name.size() - 1) {
939 ALOGE(ERROR_MSG_PREFIX
940 "does not have an /<id> component",
941 __FUNCTION__, name.c_str());
942 return BAD_VALUE;
943 }
944 std::string idVal = name.substr(instanceSlashIdx + 1);
945
946#undef ERROR_MSG_PREFIX
947
948 *major = static_cast<uint16_t>(majorVal);
949 *minor = static_cast<uint16_t>(minorVal);
950 *type = typeVal;
951 *id = idVal;
952
953 return OK;
954}
955
956
957
958CameraProviderManager::ProviderInfo::~ProviderInfo() {
959 // Destruction of ProviderInfo is only supposed to happen when the respective
960 // CameraProvider interface dies, so do not unregister callbacks.
961
962}
963
964status_t CameraProviderManager::mapToStatusT(const Status& s) {
965 switch(s) {
966 case Status::OK:
967 return OK;
968 case Status::ILLEGAL_ARGUMENT:
969 return BAD_VALUE;
970 case Status::CAMERA_IN_USE:
971 return -EBUSY;
972 case Status::MAX_CAMERAS_IN_USE:
973 return -EUSERS;
974 case Status::METHOD_NOT_SUPPORTED:
975 return UNKNOWN_TRANSACTION;
976 case Status::OPERATION_NOT_SUPPORTED:
977 return INVALID_OPERATION;
978 case Status::CAMERA_DISCONNECTED:
979 return DEAD_OBJECT;
980 case Status::INTERNAL_ERROR:
981 return INVALID_OPERATION;
982 }
983 ALOGW("Unexpected HAL status code %d", s);
984 return INVALID_OPERATION;
985}
986
987const char* CameraProviderManager::statusToString(const Status& s) {
988 switch(s) {
989 case Status::OK:
990 return "OK";
991 case Status::ILLEGAL_ARGUMENT:
992 return "ILLEGAL_ARGUMENT";
993 case Status::CAMERA_IN_USE:
994 return "CAMERA_IN_USE";
995 case Status::MAX_CAMERAS_IN_USE:
996 return "MAX_CAMERAS_IN_USE";
997 case Status::METHOD_NOT_SUPPORTED:
998 return "METHOD_NOT_SUPPORTED";
999 case Status::OPERATION_NOT_SUPPORTED:
1000 return "OPERATION_NOT_SUPPORTED";
1001 case Status::CAMERA_DISCONNECTED:
1002 return "CAMERA_DISCONNECTED";
1003 case Status::INTERNAL_ERROR:
1004 return "INTERNAL_ERROR";
1005 }
1006 ALOGW("Unexpected HAL status code %d", s);
1007 return "UNKNOWN_ERROR";
1008}
1009
1010const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
1011 switch(s) {
1012 case CameraDeviceStatus::NOT_PRESENT:
1013 return "NOT_PRESENT";
1014 case CameraDeviceStatus::PRESENT:
1015 return "PRESENT";
1016 case CameraDeviceStatus::ENUMERATING:
1017 return "ENUMERATING";
1018 }
1019 ALOGW("Unexpected HAL device status code %d", s);
1020 return "UNKNOWN_STATUS";
1021}
1022
1023const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
1024 switch(s) {
1025 case TorchModeStatus::NOT_AVAILABLE:
1026 return "NOT_AVAILABLE";
1027 case TorchModeStatus::AVAILABLE_OFF:
1028 return "AVAILABLE_OFF";
1029 case TorchModeStatus::AVAILABLE_ON:
1030 return "AVAILABLE_ON";
1031 }
1032 ALOGW("Unexpected HAL torch mode status code %d", s);
1033 return "UNKNOWN_STATUS";
1034}
1035
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08001036
1037status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
1038 const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts,
1039 /*out*/
1040 sp<VendorTagDescriptor>& descriptor) {
1041
1042 int tagCount = 0;
1043
1044 for (size_t s = 0; s < vts.size(); s++) {
1045 tagCount += vts[s].tags.size();
1046 }
1047
1048 if (tagCount < 0 || tagCount > INT32_MAX) {
1049 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
1050 return BAD_VALUE;
1051 }
1052
1053 Vector<uint32_t> tagArray;
1054 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
1055 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
1056
1057
1058 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
1059 desc->mTagCount = tagCount;
1060
1061 SortedVector<String8> sections;
1062 KeyedVector<uint32_t, String8> tagToSectionMap;
1063
1064 int idx = 0;
1065 for (size_t s = 0; s < vts.size(); s++) {
1066 const hardware::camera::common::V1_0::VendorTagSection& section = vts[s];
1067 const char *sectionName = section.sectionName.c_str();
1068 if (sectionName == NULL) {
1069 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
1070 return BAD_VALUE;
1071 }
1072 String8 sectionString(sectionName);
1073 sections.add(sectionString);
1074
1075 for (size_t j = 0; j < section.tags.size(); j++) {
1076 uint32_t tag = section.tags[j].tagId;
1077 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
1078 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
1079 return BAD_VALUE;
1080 }
1081
1082 tagArray.editItemAt(idx++) = section.tags[j].tagId;
1083
1084 const char *tagName = section.tags[j].tagName.c_str();
1085 if (tagName == NULL) {
1086 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
1087 return BAD_VALUE;
1088 }
1089 desc->mTagToNameMap.add(tag, String8(tagName));
1090 tagToSectionMap.add(tag, sectionString);
1091
1092 int tagType = (int) section.tags[j].tagType;
1093 if (tagType < 0 || tagType >= NUM_TYPES) {
1094 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
1095 return BAD_VALUE;
1096 }
1097 desc->mTagToTypeMap.add(tag, tagType);
1098 }
1099 }
1100
1101 desc->mSections = sections;
1102
1103 for (size_t i = 0; i < tagArray.size(); ++i) {
1104 uint32_t tag = tagArray[i];
1105 String8 sectionString = tagToSectionMap.valueFor(tag);
1106
1107 // Set up tag to section index map
1108 ssize_t index = sections.indexOf(sectionString);
1109 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
1110 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
1111
1112 // Set up reverse mapping
1113 ssize_t reverseIndex = -1;
1114 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
1115 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
1116 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
1117 }
1118 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
1119 }
1120
1121 descriptor = desc;
1122 return OK;
1123}
1124
1125
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001126} // namespace android