blob: f3a81cbdcd9f31c42bc60a54179e4aa47e5ab84f [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 Talvala8d942f92017-03-13 10:09:51 -070024#include <inttypes.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080025#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000026#include <functional>
27#include <camera_metadata_hidden.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080028
29namespace android {
30
31using namespace ::android::hardware::camera;
32using namespace ::android::hardware::camera::common::V1_0;
33
34namespace {
35// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
36// service manager
37const std::string kLegacyProviderName("legacy/0");
38
39// Slash-separated list of provider types to consider for use via the old camera API
40const std::string kStandardProviderTypes("internal/legacy");
41
42} // anonymous namespace
43
44CameraProviderManager::HardwareServiceInteractionProxy
45CameraProviderManager::sHardwareServiceInteractionProxy{};
46
47CameraProviderManager::~CameraProviderManager() {
48}
49
50status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
51 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080052 std::lock_guard<std::mutex> lock(mInterfaceMutex);
53 if (proxy == nullptr) {
54 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
55 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080056 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080057 mListener = listener;
58 mServiceProxy = proxy;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080059
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080060 // Registering will trigger notifications for all already-known providers
61 bool success = mServiceProxy->registerForNotifications(
62 /* instance name, empty means no filter */ "",
63 this);
64 if (!success) {
65 ALOGE("%s: Unable to register with hardware service manager for notifications "
66 "about camera providers", __FUNCTION__);
67 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080068 }
Emilian Peev5d7e5152017-02-22 15:37:48 +000069
Eino-Ville Talvala65665362017-02-24 13:07:56 -080070 // See if there's a passthrough HAL, but let's not complain if there's not
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070071 addProviderLocked(kLegacyProviderName, /*expected*/ false);
Eino-Ville Talvala65665362017-02-24 13:07:56 -080072
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080073 return OK;
74}
75
76int CameraProviderManager::getCameraCount() const {
77 std::lock_guard<std::mutex> lock(mInterfaceMutex);
78 int count = 0;
79 for (auto& provider : mProviders) {
Yin-Chia Yehe8e9e192017-03-16 15:23:51 -070080 count += provider->mUniqueDeviceCount;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080081 }
82 return count;
83}
84
85int CameraProviderManager::getStandardCameraCount() const {
86 std::lock_guard<std::mutex> lock(mInterfaceMutex);
87 int count = 0;
88 for (auto& provider : mProviders) {
89 if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) {
Yin-Chia Yehe8e9e192017-03-16 15:23:51 -070090 count += provider->mUniqueDeviceCount;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080091 }
92 }
93 return count;
94}
95
96std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
97 std::lock_guard<std::mutex> lock(mInterfaceMutex);
98 std::vector<std::string> deviceIds;
99 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700100 for (auto& id : provider->mUniqueCameraIds) {
101 deviceIds.push_back(id);
102 }
103 }
104 return deviceIds;
105}
106
107std::vector<std::string> CameraProviderManager::getStandardCameraDeviceIds() const {
108 std::lock_guard<std::mutex> lock(mInterfaceMutex);
109 std::vector<std::string> deviceIds;
110 for (auto& provider : mProviders) {
111 if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) {
112 for (auto& id : provider->mUniqueCameraIds) {
113 deviceIds.push_back(id);
114 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800115 }
116 }
117 return deviceIds;
118}
119
120bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
121 std::lock_guard<std::mutex> lock(mInterfaceMutex);
122 return isValidDeviceLocked(id, majorVersion);
123}
124
125bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
126 for (auto& provider : mProviders) {
127 for (auto& deviceInfo : provider->mDevices) {
128 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
129 return true;
130 }
131 }
132 }
133 return false;
134}
135
136bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
137 std::lock_guard<std::mutex> lock(mInterfaceMutex);
138
139 auto deviceInfo = findDeviceInfoLocked(id);
140 if (deviceInfo == nullptr) return false;
141
142 return deviceInfo->hasFlashUnit();
143}
144
145status_t CameraProviderManager::getResourceCost(const std::string &id,
146 CameraResourceCost* cost) const {
147 std::lock_guard<std::mutex> lock(mInterfaceMutex);
148
149 auto deviceInfo = findDeviceInfoLocked(id);
150 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
151
152 *cost = deviceInfo->mResourceCost;
153 return OK;
154}
155
156status_t CameraProviderManager::getCameraInfo(const std::string &id,
157 hardware::CameraInfo* info) const {
158 std::lock_guard<std::mutex> lock(mInterfaceMutex);
159
160 auto deviceInfo = findDeviceInfoLocked(id);
161 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
162
163 return deviceInfo->getCameraInfo(info);
164}
165
166status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
167 CameraMetadata* characteristics) const {
168 std::lock_guard<std::mutex> lock(mInterfaceMutex);
169
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800170 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800171 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
172
173 return deviceInfo->getCameraCharacteristics(characteristics);
174}
175
176status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
177 hardware::hidl_version *v) {
178 std::lock_guard<std::mutex> lock(mInterfaceMutex);
179
180 hardware::hidl_version maxVersion{0,0};
181 bool found = false;
182 for (auto& provider : mProviders) {
183 for (auto& deviceInfo : provider->mDevices) {
184 if (deviceInfo->mId == id) {
185 if (deviceInfo->mVersion > maxVersion) {
186 maxVersion = deviceInfo->mVersion;
187 found = true;
188 }
189 }
190 }
191 }
192 if (!found) {
193 return NAME_NOT_FOUND;
194 }
195 *v = maxVersion;
196 return OK;
197}
198
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700199bool CameraProviderManager::supportSetTorchMode(const std::string &id) {
200 std::lock_guard<std::mutex> lock(mInterfaceMutex);
201 bool support = false;
202 for (auto& provider : mProviders) {
203 auto deviceInfo = findDeviceInfoLocked(id);
204 if (deviceInfo != nullptr) {
205 provider->mInterface->isSetTorchModeSupported(
206 [&support](auto status, bool supported) {
207 if (status == Status::OK) {
208 support = supported;
209 }
210 });
211 }
212 }
213 return support;
214}
215
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800216status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
217 std::lock_guard<std::mutex> lock(mInterfaceMutex);
218
219 auto deviceInfo = findDeviceInfoLocked(id);
220 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
221
222 return deviceInfo->setTorchMode(enabled);
223}
224
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800225status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000226 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
227
228 VendorTagDescriptorCache::clearGlobalVendorTagCache();
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800229 for (auto& provider : mProviders) {
230 hardware::hidl_vec<VendorTagSection> vts;
231 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700232 hardware::Return<void> ret;
233 ret = provider->mInterface->getVendorTags(
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800234 [&](auto s, const auto& vendorTagSecs) {
235 status = s;
236 if (s == Status::OK) {
237 vts = vendorTagSecs;
238 }
239 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700240 if (!ret.isOk()) {
241 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
242 __FUNCTION__, provider->mProviderName.c_str(), ret.description().c_str());
243 return DEAD_OBJECT;
244 }
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800245 if (status != Status::OK) {
246 return mapToStatusT(status);
247 }
248
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800249 // Read all vendor tag definitions into a descriptor
250 sp<VendorTagDescriptor> desc;
251 status_t res;
252 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/desc))
253 != OK) {
254 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
255 "received error %s (%d). Camera clients will not be able to use"
256 "vendor tags", __FUNCTION__, strerror(res), res);
257 return res;
258 }
259
Emilian Peev71c73a22017-03-21 16:35:51 +0000260 tagCache->addVendorDescriptor(provider->mProviderTagid, desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800261 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000262
263 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
264
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800265 return OK;
266}
267
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800268status_t CameraProviderManager::openSession(const std::string &id,
269 const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
270 /*out*/
271 sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {
272
273 std::lock_guard<std::mutex> lock(mInterfaceMutex);
274
275 auto deviceInfo = findDeviceInfoLocked(id,
276 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
277 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
278
279 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
280
281 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700282 hardware::Return<void> ret;
283 ret = deviceInfo3->mInterface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800284 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
285 status = s;
286 if (status == Status::OK) {
287 *session = cameraSession;
288 }
289 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700290 if (!ret.isOk()) {
291 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
292 __FUNCTION__, id.c_str(), ret.description().c_str());
293 return DEAD_OBJECT;
294 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800295 return mapToStatusT(status);
296}
297
298status_t CameraProviderManager::openSession(const std::string &id,
299 const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
300 /*out*/
301 sp<hardware::camera::device::V1_0::ICameraDevice> *session) {
302
303 std::lock_guard<std::mutex> lock(mInterfaceMutex);
304
305 auto deviceInfo = findDeviceInfoLocked(id,
306 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
307 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
308
309 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
310
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700311 hardware::Return<Status> status = deviceInfo1->mInterface->open(callback);
312 if (!status.isOk()) {
313 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
314 __FUNCTION__, id.c_str(), status.description().c_str());
315 return DEAD_OBJECT;
316 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800317 if (status == Status::OK) {
318 *session = deviceInfo1->mInterface;
319 }
320 return mapToStatusT(status);
321}
322
323
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800324hardware::Return<void> CameraProviderManager::onRegistration(
325 const hardware::hidl_string& /*fqName*/,
326 const hardware::hidl_string& name,
327 bool /*preexisting*/) {
328 std::lock_guard<std::mutex> lock(mInterfaceMutex);
329
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700330 addProviderLocked(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800331 return hardware::Return<void>();
332}
333
334status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
335 std::lock_guard<std::mutex> lock(mInterfaceMutex);
336
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800337 for (auto& provider : mProviders) {
338 provider->dump(fd, args);
339 }
340 return OK;
341}
342
343CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800344 const std::string& id,
345 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800346 for (auto& provider : mProviders) {
347 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800348 if (deviceInfo->mId == id &&
349 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800350 return deviceInfo.get();
351 }
352 }
353 }
354 return nullptr;
355}
356
Emilian Peev71c73a22017-03-21 16:35:51 +0000357metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
358 const std::string& id, hardware::hidl_version minVersion,
359 hardware::hidl_version maxVersion) const {
360 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
361
362 std::lock_guard<std::mutex> lock(mInterfaceMutex);
363 for (auto& provider : mProviders) {
364 for (auto& deviceInfo : provider->mDevices) {
365 if (deviceInfo->mId == id &&
366 minVersion <= deviceInfo->mVersion &&
367 maxVersion >= deviceInfo->mVersion) {
368 return provider->mProviderTagid;
369 }
370 }
371 }
372
373 return ret;
374}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800375
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700376status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800377 for (const auto& providerInfo : mProviders) {
378 if (providerInfo->mProviderName == newProvider) {
379 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
380 newProvider.c_str());
381 return ALREADY_EXISTS;
382 }
383 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700384
385 sp<provider::V2_4::ICameraProvider> interface;
386 interface = mServiceProxy->getService(newProvider);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800387
388 if (interface == nullptr) {
389 if (expected) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700390 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
391 newProvider.c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800392 return BAD_VALUE;
393 } else {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800394 return OK;
395 }
396 }
397
398 sp<ProviderInfo> providerInfo =
399 new ProviderInfo(newProvider, interface, this);
400 status_t res = providerInfo->initialize();
401 if (res != OK) {
402 return res;
403 }
404
405 mProviders.push_back(providerInfo);
406
407 return OK;
408}
409
410status_t CameraProviderManager::removeProvider(const std::string& provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700411 std::unique_lock<std::mutex> lock(mInterfaceMutex);
412 std::vector<String8> removedDeviceIds;
413 status_t res = NAME_NOT_FOUND;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800414 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
415 if ((*it)->mProviderName == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700416 removedDeviceIds.reserve((*it)->mDevices.size());
417 for (auto& deviceInfo : (*it)->mDevices) {
418 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
419 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800420 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700421 res = OK;
422 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800423 }
424 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700425 if (res != OK) {
426 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
427 provider.c_str());
428 } else {
429 // Inform camera service of loss of presence for all the devices from this provider,
430 // without lock held for reentrancy
431 sp<StatusListener> listener = getStatusListener();
432 if (listener != nullptr) {
433 lock.unlock();
434 for (auto& id : removedDeviceIds) {
435 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
436 }
437 }
438 }
439 return res;
440}
441
442sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
443 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800444}
445
446/**** Methods for ProviderInfo ****/
447
448
449CameraProviderManager::ProviderInfo::ProviderInfo(
450 const std::string &providerName,
451 sp<provider::V2_4::ICameraProvider>& interface,
452 CameraProviderManager *manager) :
453 mProviderName(providerName),
454 mInterface(interface),
Emilian Peev71c73a22017-03-21 16:35:51 +0000455 mProviderTagid(generateVendorTagId(providerName)),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800456 mManager(manager) {
457 (void) mManager;
458}
459
460status_t CameraProviderManager::ProviderInfo::initialize() {
461 status_t res = parseProviderName(mProviderName, &mType, &mId);
462 if (res != OK) {
463 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
464 return BAD_VALUE;
465 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -0800466 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
467 mProviderName.c_str(), mInterface->isRemote());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700468 hardware::Return<Status> status = mInterface->setCallback(this);
469 if (!status.isOk()) {
470 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
471 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
472 return DEAD_OBJECT;
473 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800474 if (status != Status::OK) {
475 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
476 __FUNCTION__, mProviderName.c_str());
477 return mapToStatusT(status);
478 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700479
480 hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId);
481 if (!linked.isOk()) {
482 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
483 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
484 return DEAD_OBJECT;
485 } else if (!linked) {
486 ALOGW("%s: Unable to link to provider '%s' death notifications",
487 __FUNCTION__, mProviderName.c_str());
488 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800489
490 // Get initial list of camera devices, if any
491 std::vector<std::string> devices;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700492 hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800493 Status idStatus,
494 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
495 status = idStatus;
496 if (status == Status::OK) {
497 for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
498 devices.push_back(cameraDeviceNames[i]);
499 }
500 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700501 if (!ret.isOk()) {
502 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
503 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
504 return DEAD_OBJECT;
505 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800506 if (status != Status::OK) {
507 ALOGE("%s: Unable to query for camera devices from provider '%s'",
508 __FUNCTION__, mProviderName.c_str());
509 return mapToStatusT(status);
510 }
511
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700512 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800513 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700514 std::string id;
515 status_t res = addDevice(device,
516 hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800517 if (res != OK) {
518 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
519 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700520 continue;
521 }
522 if (listener != nullptr) {
523 listener->onDeviceStatusChanged(String8(id.c_str()), CameraDeviceStatus::PRESENT);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800524 }
525 }
526
Yin-Chia Yehe8e9e192017-03-16 15:23:51 -0700527 for (auto& device : mDevices) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700528 mUniqueCameraIds.insert(device->mId);
Yin-Chia Yehe8e9e192017-03-16 15:23:51 -0700529 }
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700530 mUniqueDeviceCount = mUniqueCameraIds.size();
Yin-Chia Yehe8e9e192017-03-16 15:23:51 -0700531
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800532 ALOGI("Camera provider %s ready with %zu camera devices",
533 mProviderName.c_str(), mDevices.size());
534
535 return OK;
536}
537
538const std::string& CameraProviderManager::ProviderInfo::getType() const {
539 return mType;
540}
541
542status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
543 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
544
545 ALOGI("Enumerating new camera device: %s", name.c_str());
546
547 uint16_t major, minor;
548 std::string type, id;
549
550 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
551 if (res != OK) {
552 return res;
553 }
554 if (type != mType) {
555 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
556 type.c_str(), mType.c_str());
557 return BAD_VALUE;
558 }
559 if (mManager->isValidDeviceLocked(id, major)) {
560 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
561 name.c_str(), id.c_str(), major);
562 return BAD_VALUE;
563 }
564
565 std::unique_ptr<DeviceInfo> deviceInfo;
566 switch (major) {
567 case 1:
Emilian Peev71c73a22017-03-21 16:35:51 +0000568 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
569 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800570 break;
571 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +0000572 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
573 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800574 break;
575 default:
576 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
577 name.c_str(), major);
578 return BAD_VALUE;
579 }
580 if (deviceInfo == nullptr) return BAD_VALUE;
581 deviceInfo->mStatus = initialStatus;
582
583 mDevices.push_back(std::move(deviceInfo));
584
585 if (parsedId != nullptr) {
586 *parsedId = id;
587 }
588 return OK;
589}
590
591status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700592 dprintf(fd, "== Camera Provider HAL %s (v2.4, %s) static info: %zu devices: ==\n",
593 mProviderName.c_str(), mInterface->isRemote() ? "remote" : "passthrough",
594 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800595
596 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800597 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
598 device->mVersion.get_major(), device->mVersion.get_minor());
599 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
600 if (device->mResourceCost.conflictingDevices.size() == 0) {
601 dprintf(fd, " Conflicting devices: None\n");
602 } else {
603 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800604 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800605 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800606 device->mResourceCost.conflictingDevices[i].c_str());
607 }
608 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -0800609 dprintf(fd, " API1 info:\n");
610 dprintf(fd, " Has a flash unit: %s\n",
611 device->hasFlashUnit() ? "true" : "false");
612 hardware::CameraInfo info;
613 status_t res = device->getCameraInfo(&info);
614 if (res != OK) {
615 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
616 strerror(-res), res);
617 } else {
618 dprintf(fd, " Facing: %s\n",
619 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
620 dprintf(fd, " Orientation: %d\n", info.orientation);
621 }
622 CameraMetadata info2;
623 res = device->getCameraCharacteristics(&info2);
624 if (res == INVALID_OPERATION) {
625 dprintf(fd, " API2 not directly supported\n");
626 } else if (res != OK) {
627 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
628 strerror(-res), res);
629 } else {
630 dprintf(fd, " API2 camera characteristics:\n");
631 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
632 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800633 }
634 return OK;
635}
636
637hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
638 const hardware::hidl_string& cameraDeviceName,
639 CameraDeviceStatus newStatus) {
640 sp<StatusListener> listener;
641 std::string id;
642 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700643 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800644 bool known = false;
645 for (auto& deviceInfo : mDevices) {
646 if (deviceInfo->mName == cameraDeviceName) {
647 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
648 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
649 deviceInfo->mStatus = newStatus;
650 // TODO: Handle device removal (NOT_PRESENT)
651 id = deviceInfo->mId;
652 known = true;
653 break;
654 }
655 }
656 // Previously unseen device; status must not be NOT_PRESENT
657 if (!known) {
658 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
659 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
660 mProviderName.c_str(), cameraDeviceName.c_str());
661 return hardware::Void();
662 }
663 addDevice(cameraDeviceName, newStatus, &id);
664 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700665 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800666 }
667 // Call without lock held to allow reentrancy into provider manager
668 if (listener != nullptr) {
669 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
670 }
671 return hardware::Void();
672}
673
674hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
675 const hardware::hidl_string& cameraDeviceName,
676 TorchModeStatus newStatus) {
677 sp<StatusListener> listener;
678 std::string id;
679 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -0800680 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800681 bool known = false;
682 for (auto& deviceInfo : mDevices) {
683 if (deviceInfo->mName == cameraDeviceName) {
684 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
685 torchStatusToString(newStatus));
686 id = deviceInfo->mId;
687 known = true;
688 break;
689 }
690 }
691 if (!known) {
692 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
693 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
694 return hardware::Void();
695 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700696 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800697 }
698 // Call without lock held to allow reentrancy into provider manager
699 if (listener != nullptr) {
700 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
701 }
702 return hardware::Void();
703}
704
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700705void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
706 const wp<hidl::base::V1_0::IBase>& who) {
707 (void) who;
708 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
709 if (cookie != mId) {
710 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
711 __FUNCTION__, cookie, mId);
712 }
713 mManager->removeProvider(mProviderName);
714}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800715
716template<class DeviceInfoT>
717std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
718 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +0000719 const std::string &name, const metadata_vendor_id_t tagId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800720 const std::string &id, uint16_t minorVersion) const {
721 Status status;
722
723 auto cameraInterface =
724 getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
725 if (cameraInterface == nullptr) return nullptr;
726
727 CameraResourceCost resourceCost;
728 cameraInterface->getResourceCost([&status, &resourceCost](
729 Status s, CameraResourceCost cost) {
730 status = s;
731 resourceCost = cost;
732 });
733 if (status != Status::OK) {
734 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
735 name.c_str(), statusToString(status));
736 return nullptr;
737 }
738 return std::unique_ptr<DeviceInfo>(
Emilian Peev71c73a22017-03-21 16:35:51 +0000739 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
740 cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800741}
742
743template<class InterfaceT>
744sp<InterfaceT>
745CameraProviderManager::ProviderInfo::getDeviceInterface(const std::string &name) const {
746 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
747 name.c_str(), InterfaceT::version.get_major());
748 return nullptr;
749}
750
751template<>
752sp<device::V1_0::ICameraDevice>
753CameraProviderManager::ProviderInfo::getDeviceInterface
754 <device::V1_0::ICameraDevice>(const std::string &name) const {
755 Status status;
756 sp<device::V1_0::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700757 hardware::Return<void> ret;
758 ret = mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800759 Status s, sp<device::V1_0::ICameraDevice> interface) {
760 status = s;
761 cameraInterface = interface;
762 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700763 if (!ret.isOk()) {
764 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
765 __FUNCTION__, name.c_str(), ret.description().c_str());
766 return nullptr;
767 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800768 if (status != Status::OK) {
769 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
770 name.c_str(), statusToString(status));
771 return nullptr;
772 }
773 return cameraInterface;
774}
775
776template<>
777sp<device::V3_2::ICameraDevice>
778CameraProviderManager::ProviderInfo::getDeviceInterface
779 <device::V3_2::ICameraDevice>(const std::string &name) const {
780 Status status;
781 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700782 hardware::Return<void> ret;
783 ret = mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800784 Status s, sp<device::V3_2::ICameraDevice> interface) {
785 status = s;
786 cameraInterface = interface;
787 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700788 if (!ret.isOk()) {
789 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
790 __FUNCTION__, name.c_str(), ret.description().c_str());
791 return nullptr;
792 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800793 if (status != Status::OK) {
794 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
795 name.c_str(), statusToString(status));
796 return nullptr;
797 }
798 return cameraInterface;
799}
800
801CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
802
803template<class InterfaceT>
804status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
805 bool enabled) {
806 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
807 return mapToStatusT(s);
808}
809
810CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +0000811 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800812 uint16_t minorVersion,
813 const CameraResourceCost& resourceCost,
814 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +0000815 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
816 resourceCost),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800817 mInterface(interface) {
818 // Get default parameters and initialize flash unit availability
819 // Requires powering on the camera device
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700820 hardware::Return<Status> status = mInterface->open(nullptr);
821 if (!status.isOk()) {
822 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
823 __FUNCTION__, mId.c_str(), status.description().c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800824 return;
825 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700826 if (status != Status::OK) {
827 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
828 mId.c_str(), CameraProviderManager::statusToString(status));
829 return;
830 }
831 hardware::Return<void> ret;
832 ret = mInterface->getParameters([this](const hardware::hidl_string& parms) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800833 mDefaultParameters.unflatten(String8(parms.c_str()));
834 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700835 if (!ret.isOk()) {
836 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
837 __FUNCTION__, mId.c_str(), status.description().c_str());
838 return;
839 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800840 const char *flashMode =
841 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
842 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
843 mHasFlashUnit = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800844 }
845
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700846 ret = mInterface->close();
847 if (!ret.isOk()) {
848 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
849 __FUNCTION__, mId.c_str(), status.description().c_str());
850 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800851}
852
853CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
854
855status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
856 return DeviceInfo::setTorchMode(mInterface, enabled);
857}
858
859status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
860 hardware::CameraInfo *info) const {
861 if (info == nullptr) return BAD_VALUE;
862
863 Status status;
864 device::V1_0::CameraInfo cInfo;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700865 hardware::Return<void> ret;
866 ret = mInterface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800867 status = s;
868 cInfo = camInfo;
869 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700870 if (!ret.isOk()) {
871 ALOGE("%s: Transaction error reading camera info from device %s: %s",
872 __FUNCTION__, mId.c_str(), ret.description().c_str());
873 return DEAD_OBJECT;
874 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800875 if (status != Status::OK) {
876 return mapToStatusT(status);
877 }
878
879 switch(cInfo.facing) {
880 case device::V1_0::CameraFacing::BACK:
881 info->facing = hardware::CAMERA_FACING_BACK;
882 break;
883 case device::V1_0::CameraFacing::EXTERNAL:
884 // Map external to front for legacy API
885 case device::V1_0::CameraFacing::FRONT:
886 info->facing = hardware::CAMERA_FACING_FRONT;
887 break;
888 default:
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700889 ALOGW("%s: Device %s: Unknown camera facing: %d",
890 __FUNCTION__, mId.c_str(), cInfo.facing);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800891 info->facing = hardware::CAMERA_FACING_BACK;
892 }
893 info->orientation = cInfo.orientation;
894
895 return OK;
896}
897
898CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +0000899 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800900 uint16_t minorVersion,
901 const CameraResourceCost& resourceCost,
902 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +0000903 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
904 resourceCost),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800905 mInterface(interface) {
906 // Get camera characteristics and initialize flash unit availability
907 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700908 hardware::Return<void> ret;
909 ret = mInterface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800910 device::V3_2::CameraMetadata metadata) {
911 status = s;
912 if (s == Status::OK) {
913 camera_metadata_t *buffer =
914 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -0700915 size_t expectedSize = metadata.size();
916 int res = validate_camera_metadata_structure(buffer, &expectedSize);
917 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
918 set_camera_metadata_vendor_id(buffer, mProviderTagid);
919 mCameraCharacteristics = buffer;
920 } else {
921 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
922 status = Status::INTERNAL_ERROR;
923 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800924 }
925 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700926 if (!ret.isOk()) {
927 ALOGE("%s: Transaction error getting camera characteristics for device %s"
928 " to check for a flash unit: %s", __FUNCTION__, mId.c_str(),
929 ret.description().c_str());
930 return;
931 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800932 if (status != Status::OK) {
933 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
934 __FUNCTION__, mId.c_str(), CameraProviderManager::statusToString(status), status);
935 return;
936 }
937 camera_metadata_entry flashAvailable =
938 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
939 if (flashAvailable.count == 1 &&
940 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
941 mHasFlashUnit = true;
942 } else {
943 mHasFlashUnit = false;
944 }
945}
946
947CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
948
949status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
950 return DeviceInfo::setTorchMode(mInterface, enabled);
951}
952
953status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
954 hardware::CameraInfo *info) const {
955 if (info == nullptr) return BAD_VALUE;
956
957 camera_metadata_ro_entry facing =
958 mCameraCharacteristics.find(ANDROID_LENS_FACING);
959 if (facing.count == 1) {
960 switch (facing.data.u8[0]) {
961 case ANDROID_LENS_FACING_BACK:
962 info->facing = hardware::CAMERA_FACING_BACK;
963 break;
964 case ANDROID_LENS_FACING_EXTERNAL:
965 // Map external to front for legacy API
966 case ANDROID_LENS_FACING_FRONT:
967 info->facing = hardware::CAMERA_FACING_FRONT;
968 break;
969 }
970 } else {
971 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
972 return NAME_NOT_FOUND;
973 }
974
975 camera_metadata_ro_entry orientation =
976 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
977 if (orientation.count == 1) {
978 info->orientation = orientation.data.i32[0];
979 } else {
980 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
981 return NAME_NOT_FOUND;
982 }
983
984 return OK;
985}
986
987status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
988 CameraMetadata *characteristics) const {
989 if (characteristics == nullptr) return BAD_VALUE;
990
991 *characteristics = mCameraCharacteristics;
992 return OK;
993}
994
995status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
996 std::string *type, uint32_t *id) {
997 // Format must be "<type>/<id>"
998#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
999 "Should match '<type>/<id>' - "
1000
1001 if (!type || !id) return INVALID_OPERATION;
1002
1003 std::string::size_type slashIdx = name.find('/');
1004 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
1005 ALOGE(ERROR_MSG_PREFIX
1006 "does not have / separator between type and id",
1007 __FUNCTION__, name.c_str());
1008 return BAD_VALUE;
1009 }
1010
1011 std::string typeVal = name.substr(0, slashIdx);
1012
1013 char *endPtr;
1014 errno = 0;
1015 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
1016 if (errno != 0) {
1017 ALOGE(ERROR_MSG_PREFIX
1018 "cannot parse provider id as an integer: %s (%d)",
1019 __FUNCTION__, name.c_str(), strerror(errno), errno);
1020 return BAD_VALUE;
1021 }
1022 if (endPtr != name.c_str() + name.size()) {
1023 ALOGE(ERROR_MSG_PREFIX
1024 "provider id has unexpected length",
1025 __FUNCTION__, name.c_str());
1026 return BAD_VALUE;
1027 }
1028 if (idVal < 0) {
1029 ALOGE(ERROR_MSG_PREFIX
1030 "id is negative: %ld",
1031 __FUNCTION__, name.c_str(), idVal);
1032 return BAD_VALUE;
1033 }
1034
1035#undef ERROR_MSG_PREFIX
1036
1037 *type = typeVal;
1038 *id = static_cast<uint32_t>(idVal);
1039
1040 return OK;
1041}
1042
Emilian Peev71c73a22017-03-21 16:35:51 +00001043metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
1044 const std::string &name) {
1045 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
1046 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
1047 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
1048 ret = 0;
1049 }
1050
1051 return ret;
1052}
1053
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001054status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
1055 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
1056
1057 // Format must be "device@<major>.<minor>/<type>/<id>"
1058
1059#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
1060 "Should match 'device@<major>.<minor>/<type>/<id>' - "
1061
1062 if (!major || !minor || !type || !id) return INVALID_OPERATION;
1063
1064 // Verify starting prefix
1065 const char expectedPrefix[] = "device@";
1066
1067 if (name.find(expectedPrefix) != 0) {
1068 ALOGE(ERROR_MSG_PREFIX
1069 "does not start with '%s'",
1070 __FUNCTION__, name.c_str(), expectedPrefix);
1071 return BAD_VALUE;
1072 }
1073
1074 // Extract major/minor versions
1075 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
1076 std::string::size_type dotIdx = name.find('.', atIdx);
1077 if (dotIdx == std::string::npos) {
1078 ALOGE(ERROR_MSG_PREFIX
1079 "does not have @<major>. version section",
1080 __FUNCTION__, name.c_str());
1081 return BAD_VALUE;
1082 }
1083 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
1084 if (typeSlashIdx == std::string::npos) {
1085 ALOGE(ERROR_MSG_PREFIX
1086 "does not have .<minor>/ version section",
1087 __FUNCTION__, name.c_str());
1088 return BAD_VALUE;
1089 }
1090
1091 char *endPtr;
1092 errno = 0;
1093 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
1094 if (errno != 0) {
1095 ALOGE(ERROR_MSG_PREFIX
1096 "cannot parse major version: %s (%d)",
1097 __FUNCTION__, name.c_str(), strerror(errno), errno);
1098 return BAD_VALUE;
1099 }
1100 if (endPtr != name.c_str() + dotIdx) {
1101 ALOGE(ERROR_MSG_PREFIX
1102 "major version has unexpected length",
1103 __FUNCTION__, name.c_str());
1104 return BAD_VALUE;
1105 }
1106 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
1107 if (errno != 0) {
1108 ALOGE(ERROR_MSG_PREFIX
1109 "cannot parse minor version: %s (%d)",
1110 __FUNCTION__, name.c_str(), strerror(errno), errno);
1111 return BAD_VALUE;
1112 }
1113 if (endPtr != name.c_str() + typeSlashIdx) {
1114 ALOGE(ERROR_MSG_PREFIX
1115 "minor version has unexpected length",
1116 __FUNCTION__, name.c_str());
1117 return BAD_VALUE;
1118 }
1119 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
1120 ALOGE(ERROR_MSG_PREFIX
1121 "major/minor version is out of range of uint16_t: %ld.%ld",
1122 __FUNCTION__, name.c_str(), majorVal, minorVal);
1123 return BAD_VALUE;
1124 }
1125
1126 // Extract type and id
1127
1128 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
1129 if (instanceSlashIdx == std::string::npos) {
1130 ALOGE(ERROR_MSG_PREFIX
1131 "does not have /<type>/ component",
1132 __FUNCTION__, name.c_str());
1133 return BAD_VALUE;
1134 }
1135 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
1136
1137 if (instanceSlashIdx == name.size() - 1) {
1138 ALOGE(ERROR_MSG_PREFIX
1139 "does not have an /<id> component",
1140 __FUNCTION__, name.c_str());
1141 return BAD_VALUE;
1142 }
1143 std::string idVal = name.substr(instanceSlashIdx + 1);
1144
1145#undef ERROR_MSG_PREFIX
1146
1147 *major = static_cast<uint16_t>(majorVal);
1148 *minor = static_cast<uint16_t>(minorVal);
1149 *type = typeVal;
1150 *id = idVal;
1151
1152 return OK;
1153}
1154
1155
1156
1157CameraProviderManager::ProviderInfo::~ProviderInfo() {
1158 // Destruction of ProviderInfo is only supposed to happen when the respective
1159 // CameraProvider interface dies, so do not unregister callbacks.
1160
1161}
1162
1163status_t CameraProviderManager::mapToStatusT(const Status& s) {
1164 switch(s) {
1165 case Status::OK:
1166 return OK;
1167 case Status::ILLEGAL_ARGUMENT:
1168 return BAD_VALUE;
1169 case Status::CAMERA_IN_USE:
1170 return -EBUSY;
1171 case Status::MAX_CAMERAS_IN_USE:
1172 return -EUSERS;
1173 case Status::METHOD_NOT_SUPPORTED:
1174 return UNKNOWN_TRANSACTION;
1175 case Status::OPERATION_NOT_SUPPORTED:
1176 return INVALID_OPERATION;
1177 case Status::CAMERA_DISCONNECTED:
1178 return DEAD_OBJECT;
1179 case Status::INTERNAL_ERROR:
1180 return INVALID_OPERATION;
1181 }
1182 ALOGW("Unexpected HAL status code %d", s);
1183 return INVALID_OPERATION;
1184}
1185
1186const char* CameraProviderManager::statusToString(const Status& s) {
1187 switch(s) {
1188 case Status::OK:
1189 return "OK";
1190 case Status::ILLEGAL_ARGUMENT:
1191 return "ILLEGAL_ARGUMENT";
1192 case Status::CAMERA_IN_USE:
1193 return "CAMERA_IN_USE";
1194 case Status::MAX_CAMERAS_IN_USE:
1195 return "MAX_CAMERAS_IN_USE";
1196 case Status::METHOD_NOT_SUPPORTED:
1197 return "METHOD_NOT_SUPPORTED";
1198 case Status::OPERATION_NOT_SUPPORTED:
1199 return "OPERATION_NOT_SUPPORTED";
1200 case Status::CAMERA_DISCONNECTED:
1201 return "CAMERA_DISCONNECTED";
1202 case Status::INTERNAL_ERROR:
1203 return "INTERNAL_ERROR";
1204 }
1205 ALOGW("Unexpected HAL status code %d", s);
1206 return "UNKNOWN_ERROR";
1207}
1208
1209const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
1210 switch(s) {
1211 case CameraDeviceStatus::NOT_PRESENT:
1212 return "NOT_PRESENT";
1213 case CameraDeviceStatus::PRESENT:
1214 return "PRESENT";
1215 case CameraDeviceStatus::ENUMERATING:
1216 return "ENUMERATING";
1217 }
1218 ALOGW("Unexpected HAL device status code %d", s);
1219 return "UNKNOWN_STATUS";
1220}
1221
1222const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
1223 switch(s) {
1224 case TorchModeStatus::NOT_AVAILABLE:
1225 return "NOT_AVAILABLE";
1226 case TorchModeStatus::AVAILABLE_OFF:
1227 return "AVAILABLE_OFF";
1228 case TorchModeStatus::AVAILABLE_ON:
1229 return "AVAILABLE_ON";
1230 }
1231 ALOGW("Unexpected HAL torch mode status code %d", s);
1232 return "UNKNOWN_STATUS";
1233}
1234
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08001235
1236status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
1237 const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts,
1238 /*out*/
1239 sp<VendorTagDescriptor>& descriptor) {
1240
1241 int tagCount = 0;
1242
1243 for (size_t s = 0; s < vts.size(); s++) {
1244 tagCount += vts[s].tags.size();
1245 }
1246
1247 if (tagCount < 0 || tagCount > INT32_MAX) {
1248 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
1249 return BAD_VALUE;
1250 }
1251
1252 Vector<uint32_t> tagArray;
1253 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
1254 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
1255
1256
1257 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
1258 desc->mTagCount = tagCount;
1259
1260 SortedVector<String8> sections;
1261 KeyedVector<uint32_t, String8> tagToSectionMap;
1262
1263 int idx = 0;
1264 for (size_t s = 0; s < vts.size(); s++) {
1265 const hardware::camera::common::V1_0::VendorTagSection& section = vts[s];
1266 const char *sectionName = section.sectionName.c_str();
1267 if (sectionName == NULL) {
1268 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
1269 return BAD_VALUE;
1270 }
1271 String8 sectionString(sectionName);
1272 sections.add(sectionString);
1273
1274 for (size_t j = 0; j < section.tags.size(); j++) {
1275 uint32_t tag = section.tags[j].tagId;
1276 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
1277 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
1278 return BAD_VALUE;
1279 }
1280
1281 tagArray.editItemAt(idx++) = section.tags[j].tagId;
1282
1283 const char *tagName = section.tags[j].tagName.c_str();
1284 if (tagName == NULL) {
1285 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
1286 return BAD_VALUE;
1287 }
1288 desc->mTagToNameMap.add(tag, String8(tagName));
1289 tagToSectionMap.add(tag, sectionString);
1290
1291 int tagType = (int) section.tags[j].tagType;
1292 if (tagType < 0 || tagType >= NUM_TYPES) {
1293 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
1294 return BAD_VALUE;
1295 }
1296 desc->mTagToTypeMap.add(tag, tagType);
1297 }
1298 }
1299
1300 desc->mSections = sections;
1301
1302 for (size_t i = 0; i < tagArray.size(); ++i) {
1303 uint32_t tag = tagArray[i];
1304 String8 sectionString = tagToSectionMap.valueFor(tag);
1305
1306 // Set up tag to section index map
1307 ssize_t index = sections.indexOf(sectionString);
1308 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
1309 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
1310
1311 // Set up reverse mapping
1312 ssize_t reverseIndex = -1;
1313 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
1314 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
1315 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
1316 }
1317 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
1318 }
1319
1320 descriptor = desc;
1321 return OK;
1322}
1323
1324
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001325} // namespace android