blob: ad4fc5f8343eef0cfbcb1b5c8878691537febfdf [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
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070023#include <android/hardware/camera/device/3.5/ICameraDevice.h>
24
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080025#include <algorithm>
Yin-Chia Yeh65405092017-01-13 15:42:28 -080026#include <chrono>
Emilian Peevcbf174b2019-01-25 14:38:59 -080027#include "common/DepthPhotoProcessor.h"
28#include <dlfcn.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070029#include <future>
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070030#include <inttypes.h>
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070031#include <hardware/camera_common.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080032#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000033#include <functional>
34#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080035#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070036#include <android-base/logging.h>
37#include <cutils/properties.h>
38#include <hwbinder/IPCThreadState.h>
39#include <utils/Trace.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080040
41namespace android {
42
43using namespace ::android::hardware::camera;
44using namespace ::android::hardware::camera::common::V1_0;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070045using std::literals::chrono_literals::operator""s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080046
47namespace {
48// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
49// service manager
50const std::string kLegacyProviderName("legacy/0");
Yin-Chia Yehd78041a2018-01-20 13:45:38 -080051const std::string kExternalProviderName("external/0");
Peter Kalauskasa29c1352018-10-10 12:05:42 -070052const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
53
54// The extra amount of time to hold a reference to an ICameraProvider after it is no longer needed.
55// Hold the reference for this extra time so that if the camera is unreferenced and then referenced
56// again quickly, we do not let the HAL exit and then need to immediately restart it. An example
57// when this could happen is switching from a front-facing to a rear-facing camera. If the HAL were
58// to exit during the camera switch, the camera could appear janky to the user.
59const std::chrono::system_clock::duration kCameraKeepAliveDelay = 3s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080060
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080061} // anonymous namespace
62
Emilian Peev538c90e2018-12-17 18:03:19 +000063const float CameraProviderManager::kDepthARTolerance = .1f;
64
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080065CameraProviderManager::HardwareServiceInteractionProxy
66CameraProviderManager::sHardwareServiceInteractionProxy{};
67
68CameraProviderManager::~CameraProviderManager() {
69}
70
71status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
72 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080073 std::lock_guard<std::mutex> lock(mInterfaceMutex);
74 if (proxy == nullptr) {
75 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
76 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080077 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080078 mListener = listener;
79 mServiceProxy = proxy;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080080
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080081 // Registering will trigger notifications for all already-known providers
82 bool success = mServiceProxy->registerForNotifications(
83 /* instance name, empty means no filter */ "",
84 this);
85 if (!success) {
86 ALOGE("%s: Unable to register with hardware service manager for notifications "
87 "about camera providers", __FUNCTION__);
88 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080089 }
Emilian Peev5d7e5152017-02-22 15:37:48 +000090
Eino-Ville Talvala65665362017-02-24 13:07:56 -080091 // See if there's a passthrough HAL, but let's not complain if there's not
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070092 addProviderLocked(kLegacyProviderName, /*expected*/ false);
Yin-Chia Yehd78041a2018-01-20 13:45:38 -080093 addProviderLocked(kExternalProviderName, /*expected*/ false);
Eino-Ville Talvala65665362017-02-24 13:07:56 -080094
Peter Kalauskasa29c1352018-10-10 12:05:42 -070095 IPCThreadState::self()->flushCommands();
96
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080097 return OK;
98}
99
100int CameraProviderManager::getCameraCount() const {
101 std::lock_guard<std::mutex> lock(mInterfaceMutex);
102 int count = 0;
103 for (auto& provider : mProviders) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800104 count += provider->mUniqueCameraIds.size();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800105 }
106 return count;
107}
108
109std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
110 std::lock_guard<std::mutex> lock(mInterfaceMutex);
111 std::vector<std::string> deviceIds;
112 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700113 for (auto& id : provider->mUniqueCameraIds) {
114 deviceIds.push_back(id);
115 }
116 }
117 return deviceIds;
118}
119
Emilian Peevf53f66e2017-04-11 14:29:43 +0100120std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700121 std::lock_guard<std::mutex> lock(mInterfaceMutex);
122 std::vector<std::string> deviceIds;
123 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700124 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
125
126 // API1 app doesn't handle logical and physical camera devices well. So
127 // for each [logical, physical1, physical2, ...] id combo, only take the
128 // first id advertised by HAL, and filter out the rest.
129 filterLogicalCameraIdsLocked(providerDeviceIds);
130
131 deviceIds.insert(deviceIds.end(), providerDeviceIds.begin(), providerDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800132 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800133
134 std::sort(deviceIds.begin(), deviceIds.end(),
135 [](const std::string& a, const std::string& b) -> bool {
136 uint32_t aUint = 0, bUint = 0;
137 bool aIsUint = base::ParseUint(a, &aUint);
138 bool bIsUint = base::ParseUint(b, &bUint);
139
140 // Uint device IDs first
141 if (aIsUint && bIsUint) {
142 return aUint < bUint;
143 } else if (aIsUint) {
144 return true;
145 } else if (bIsUint) {
146 return false;
147 }
148 // Simple string compare if both id are not uint
149 return a < b;
150 });
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800151 return deviceIds;
152}
153
154bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
155 std::lock_guard<std::mutex> lock(mInterfaceMutex);
156 return isValidDeviceLocked(id, majorVersion);
157}
158
159bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
160 for (auto& provider : mProviders) {
161 for (auto& deviceInfo : provider->mDevices) {
162 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
163 return true;
164 }
165 }
166 }
167 return false;
168}
169
170bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
171 std::lock_guard<std::mutex> lock(mInterfaceMutex);
172
173 auto deviceInfo = findDeviceInfoLocked(id);
174 if (deviceInfo == nullptr) return false;
175
176 return deviceInfo->hasFlashUnit();
177}
178
179status_t CameraProviderManager::getResourceCost(const std::string &id,
180 CameraResourceCost* cost) const {
181 std::lock_guard<std::mutex> lock(mInterfaceMutex);
182
183 auto deviceInfo = findDeviceInfoLocked(id);
184 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
185
186 *cost = deviceInfo->mResourceCost;
187 return OK;
188}
189
190status_t CameraProviderManager::getCameraInfo(const std::string &id,
191 hardware::CameraInfo* info) const {
192 std::lock_guard<std::mutex> lock(mInterfaceMutex);
193
194 auto deviceInfo = findDeviceInfoLocked(id);
195 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
196
197 return deviceInfo->getCameraInfo(info);
198}
199
Emilian Peev35ae8262018-11-08 13:11:32 +0000200status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
201 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
202 bool *status /*out*/) const {
203 std::lock_guard<std::mutex> lock(mInterfaceMutex);
204
205 auto deviceInfo = findDeviceInfoLocked(id);
206 if (deviceInfo == nullptr) {
207 return NAME_NOT_FOUND;
208 }
209
210 return deviceInfo->isSessionConfigurationSupported(configuration, status);
211}
212
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800213status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
214 CameraMetadata* characteristics) const {
215 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700216 return getCameraCharacteristicsLocked(id, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800217}
218
219status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
220 hardware::hidl_version *v) {
221 std::lock_guard<std::mutex> lock(mInterfaceMutex);
222
223 hardware::hidl_version maxVersion{0,0};
224 bool found = false;
225 for (auto& provider : mProviders) {
226 for (auto& deviceInfo : provider->mDevices) {
227 if (deviceInfo->mId == id) {
228 if (deviceInfo->mVersion > maxVersion) {
229 maxVersion = deviceInfo->mVersion;
230 found = true;
231 }
232 }
233 }
234 }
235 if (!found) {
236 return NAME_NOT_FOUND;
237 }
238 *v = maxVersion;
239 return OK;
240}
241
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700242bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700243 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700244 for (auto& provider : mProviders) {
245 auto deviceInfo = findDeviceInfoLocked(id);
246 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700247 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700248 }
249 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700250 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700251}
252
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800253status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
254 std::lock_guard<std::mutex> lock(mInterfaceMutex);
255
256 auto deviceInfo = findDeviceInfoLocked(id);
257 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
258
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700259 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
260 // that are currently in use.
261 const sp<provider::V2_4::ICameraProvider> interface =
262 deviceInfo->mParentProvider->startProviderInterface();
263 if (interface == nullptr) {
264 return DEAD_OBJECT;
265 }
266 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
267
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800268 return deviceInfo->setTorchMode(enabled);
269}
270
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800271status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000272 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
273
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800274 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800275 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800276 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000277
278 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
279
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800280 return OK;
281}
282
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800283status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800284 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800285 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800286 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800287
288 std::lock_guard<std::mutex> lock(mInterfaceMutex);
289
290 auto deviceInfo = findDeviceInfoLocked(id,
291 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
292 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
293
294 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700295 const sp<provider::V2_4::ICameraProvider> provider =
296 deviceInfo->mParentProvider->startProviderInterface();
297 if (provider == nullptr) {
298 return DEAD_OBJECT;
299 }
300 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800301
302 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700303 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700304 auto interface = deviceInfo3->startDeviceInterface<
305 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
306 if (interface == nullptr) {
307 return DEAD_OBJECT;
308 }
309
310 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800311 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
312 status = s;
313 if (status == Status::OK) {
314 *session = cameraSession;
315 }
316 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700317 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700318 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700319 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
320 __FUNCTION__, id.c_str(), ret.description().c_str());
321 return DEAD_OBJECT;
322 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800323 return mapToStatusT(status);
324}
325
326status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800327 const sp<device::V1_0::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800328 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800329 sp<device::V1_0::ICameraDevice> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800330
331 std::lock_guard<std::mutex> lock(mInterfaceMutex);
332
333 auto deviceInfo = findDeviceInfoLocked(id,
334 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
335 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
336
337 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700338 const sp<provider::V2_4::ICameraProvider> provider =
339 deviceInfo->mParentProvider->startProviderInterface();
340 if (provider == nullptr) {
341 return DEAD_OBJECT;
342 }
343 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800344
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700345 auto interface = deviceInfo1->startDeviceInterface<
346 CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT>();
347 if (interface == nullptr) {
348 return DEAD_OBJECT;
349 }
350 hardware::Return<Status> status = interface->open(callback);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700351 if (!status.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700352 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700353 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
354 __FUNCTION__, id.c_str(), status.description().c_str());
355 return DEAD_OBJECT;
356 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800357 if (status == Status::OK) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700358 *session = interface;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800359 }
360 return mapToStatusT(status);
361}
362
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700363void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
364 sp<provider::V2_4::ICameraProvider> provider) {
365 if (!kEnableLazyHal) {
366 return;
367 }
368 ALOGI("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
369 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
370 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
371 if (usageType == DeviceMode::TORCH) {
372 primaryMap = &mTorchProviderByCameraId;
373 alternateMap = &mCameraProviderByCameraId;
374 } else {
375 primaryMap = &mCameraProviderByCameraId;
376 alternateMap = &mTorchProviderByCameraId;
377 }
378 auto id = cameraId.c_str();
379 (*primaryMap)[id] = provider;
380 auto search = alternateMap->find(id);
381 if (search != alternateMap->end()) {
382 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
383 "That should not be possible", __FUNCTION__, id);
384 }
385 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
386}
387
388void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
389 if (!kEnableLazyHal) {
390 return;
391 }
392 ALOGI("Removing camera device %s", cameraId.c_str());
393 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
394 if (usageType == DeviceMode::TORCH) {
395 providerMap = &mTorchProviderByCameraId;
396 } else {
397 providerMap = &mCameraProviderByCameraId;
398 }
399 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
400 auto search = providerMap->find(cameraId.c_str());
401 if (search != providerMap->end()) {
402 auto ptr = search->second;
403 auto future = std::async(std::launch::async, [ptr] {
404 std::this_thread::sleep_for(kCameraKeepAliveDelay);
405 IPCThreadState::self()->flushCommands();
406 });
407 providerMap->erase(cameraId.c_str());
408 } else {
409 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
410 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
411 cameraId.c_str());
412 }
413}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800414
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800415hardware::Return<void> CameraProviderManager::onRegistration(
416 const hardware::hidl_string& /*fqName*/,
417 const hardware::hidl_string& name,
418 bool /*preexisting*/) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700419 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100420 {
421 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800422
Emilian Peevaee727d2017-05-04 16:35:48 +0100423 addProviderLocked(name);
424 }
425
426 sp<StatusListener> listener = getStatusListener();
427 if (nullptr != listener.get()) {
428 listener->onNewProviderRegistered();
429 }
430
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700431 IPCThreadState::self()->flushCommands();
432
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800433 return hardware::Return<void>();
434}
435
436status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
437 std::lock_guard<std::mutex> lock(mInterfaceMutex);
438
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800439 for (auto& provider : mProviders) {
440 provider->dump(fd, args);
441 }
442 return OK;
443}
444
445CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800446 const std::string& id,
447 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800448 for (auto& provider : mProviders) {
449 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800450 if (deviceInfo->mId == id &&
451 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800452 return deviceInfo.get();
453 }
454 }
455 }
456 return nullptr;
457}
458
Emilian Peev71c73a22017-03-21 16:35:51 +0000459metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
460 const std::string& id, hardware::hidl_version minVersion,
461 hardware::hidl_version maxVersion) const {
462 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
463
464 std::lock_guard<std::mutex> lock(mInterfaceMutex);
465 for (auto& provider : mProviders) {
466 for (auto& deviceInfo : provider->mDevices) {
467 if (deviceInfo->mId == id &&
468 minVersion <= deviceInfo->mVersion &&
469 maxVersion >= deviceInfo->mVersion) {
470 return provider->mProviderTagid;
471 }
472 }
473 }
474
475 return ret;
476}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800477
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700478void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
479 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700480
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700481 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700482 for (size_t i = 0; i < entryCap.count; ++i) {
483 uint8_t capability = entryCap.data.u8[i];
484 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700485 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700486 break;
487 }
488 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700489 if (!mIsLogicalCamera) {
490 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700491 }
492
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700493 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
494 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700495 const uint8_t* ids = entryIds.data.u8;
496 size_t start = 0;
497 for (size_t i = 0; i < entryIds.count; ++i) {
498 if (ids[i] == '\0') {
499 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700500 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700501 }
502 start = i+1;
503 }
504 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700505}
506
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800507bool CameraProviderManager::ProviderInfo::DeviceInfo3::isPublicallyHiddenSecureCamera() {
508 camera_metadata_entry_t entryCap;
509 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
510 if (entryCap.count != 1) {
511 // Do NOT hide this camera device if the capabilities specify anything more
512 // than ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA.
513 return false;
514 }
515 return entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA;
516}
517
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000518void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
519 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
520 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
521 if (sizes == nullptr) {
522 return;
523 }
524
525 auto scalerDims = ch.find(tag);
526 if (scalerDims.count > 0) {
527 // Scaler entry contains 4 elements (format, width, height, type)
528 for (size_t i = 0; i < scalerDims.count; i += 4) {
529 if ((scalerDims.data.i32[i] == format) &&
530 (scalerDims.data.i32[i+3] ==
531 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
532 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
533 scalerDims.data.i32[i+2]));
534 }
535 }
536 }
537}
538
539void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
540 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
541 const std::vector<std::tuple<size_t, size_t>>& sizes,
542 std::vector<int64_t> *durations/*out*/) {
543 if (durations == nullptr) {
544 return;
545 }
546
547 auto availableDurations = ch.find(tag);
548 if (availableDurations.count > 0) {
549 // Duration entry contains 4 elements (format, width, height, duration)
550 for (size_t i = 0; i < availableDurations.count; i += 4) {
551 for (const auto& size : sizes) {
552 int64_t width = std::get<0>(size);
553 int64_t height = std::get<1>(size);
554 if ((availableDurations.data.i64[i] == format) &&
555 (availableDurations.data.i64[i+1] == width) &&
556 (availableDurations.data.i64[i+2] == height)) {
557 durations->push_back(availableDurations.data.i64[i+3]);
558 }
559 }
560 }
561 }
562}
563void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
564 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
565 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
566 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
567 return;
568 }
569
570 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
571 // Processing time on camera service side can vary greatly depending on multiple
572 // variables which are not under our control. Make a guesstimate by taking the maximum
573 // corresponding duration value from depth and blob.
574 auto depthDuration = depthDurations.begin();
575 auto blobDuration = blobDurations.begin();
576 dynamicDepthDurations->reserve(depthDurations.size());
577 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
578 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
579 depthDuration++; blobDuration++;
580 }
581}
582
583void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
584 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
585 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
586 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
587 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
588 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
589 return;
590 }
591
592 // The dynamic depth spec. does not mention how close the AR ratio should be.
593 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000594 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000595
596 for (const auto& blobSize : blobSizes) {
597 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
598 static_cast<float>(std::get<1>(blobSize));
599 bool found = false;
600 for (const auto& depthSize : depthSizes) {
601 if (depthSize == blobSize) {
602 internalDepthSizes->push_back(depthSize);
603 found = true;
604 break;
605 } else {
606 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
607 static_cast<float>(std::get<1>(depthSize));
608 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
609 internalDepthSizes->push_back(depthSize);
610 found = true;
611 break;
612 }
613 }
614 }
615
616 if (found) {
617 dynamicDepthSizes->push_back(blobSize);
618 }
619 }
620}
621
Emilian Peevcbf174b2019-01-25 14:38:59 -0800622bool CameraProviderManager::ProviderInfo::DeviceInfo3::isDepthPhotoLibraryPresent() {
623 static bool libraryPresent = false;
624 static bool initialized = false;
625 if (initialized) {
626 return libraryPresent;
627 } else {
628 initialized = true;
629 }
630
631 void* depthLibHandle = dlopen(camera3::kDepthPhotoLibrary, RTLD_NOW | RTLD_LOCAL);
632 if (depthLibHandle == nullptr) {
633 return false;
634 }
635
636 auto processFunc = dlsym(depthLibHandle, camera3::kDepthPhotoProcessFunction);
637 if (processFunc != nullptr) {
638 libraryPresent = true;
639 } else {
640 libraryPresent = false;
641 }
642 dlclose(depthLibHandle);
643
644 return libraryPresent;
645}
646
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000647status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags() {
648 uint32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
649 uint32_t depthSizesTag = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS;
650 auto& c = mCameraCharacteristics;
651 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
652 supportedDynamicDepthSizes, internalDepthSizes;
653 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
654 if (chTags.count == 0) {
655 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
656 return BAD_VALUE;
657 }
658
659 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
660 depthExclTag) != (chTags.data.i32 + chTags.count);
661 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
662 depthExclTag) != (chTags.data.i32 + chTags.count);
663 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
664 // No depth support, nothing more to do.
665 return OK;
666 }
667
668 auto depthExclusiveEntry = c.find(depthExclTag);
669 if (depthExclusiveEntry.count > 0) {
670 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
671 // Depth support is exclusive, nothing more to do.
672 return OK;
673 }
674 } else {
675 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
676 return BAD_VALUE;
677 }
678
679 getSupportedSizes(c, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, HAL_PIXEL_FORMAT_BLOB,
680 &supportedBlobSizes);
681 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
682 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
683 // Nothing to do in this case.
684 return OK;
685 }
686
687 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
688 &supportedDynamicDepthSizes, &internalDepthSizes);
689 if (supportedDynamicDepthSizes.empty()) {
690 ALOGE("%s: No dynamic depth size matched!", __func__);
691 // Nothing more to do.
692 return OK;
693 }
694
Emilian Peevcbf174b2019-01-25 14:38:59 -0800695 if(!isDepthPhotoLibraryPresent()) {
696 // Depth photo processing library is not present, nothing more to do.
697 return OK;
698 }
699
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000700 std::vector<int32_t> dynamicDepthEntries;
701 for (const auto& it : supportedDynamicDepthSizes) {
702 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
703 static_cast<int32_t> (std::get<1>(it)),
704 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
705 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
706 }
707
708 std::vector<int64_t> depthMinDurations, depthStallDurations;
709 std::vector<int64_t> blobMinDurations, blobStallDurations;
710 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
711
712 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,
713 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthMinDurations);
714 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
715 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobMinDurations);
716 if (blobMinDurations.empty() || depthMinDurations.empty() ||
717 (depthMinDurations.size() != blobMinDurations.size())) {
718 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
719 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
720 return BAD_VALUE;
721 }
722
723 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS,
724 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthStallDurations);
725 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
726 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobStallDurations);
727 if (blobStallDurations.empty() || depthStallDurations.empty() ||
728 (depthStallDurations.size() != blobStallDurations.size())) {
729 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
730 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
731 return BAD_VALUE;
732 }
733
734 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
735 &dynamicDepthMinDurations);
736 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
737 &dynamicDepthStallDurations);
738 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
739 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
740 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
741 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
742 return BAD_VALUE;
743 }
744
745 std::vector<int64_t> dynamicDepthMinDurationEntries;
746 auto itDuration = dynamicDepthMinDurations.begin();
747 auto itSize = supportedDynamicDepthSizes.begin();
748 while (itDuration != dynamicDepthMinDurations.end()) {
749 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
750 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
751 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
752 entry + 4);
753 itDuration++; itSize++;
754 }
755
756 std::vector<int64_t> dynamicDepthStallDurationEntries;
757 itDuration = dynamicDepthStallDurations.begin();
758 itSize = supportedDynamicDepthSizes.begin();
759 while (itDuration != dynamicDepthStallDurations.end()) {
760 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
761 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
762 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
763 entry + 4);
764 itDuration++; itSize++;
765 }
766
767 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
768 dynamicDepthEntries.data(), dynamicDepthEntries.size());
769 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,
770 dynamicDepthMinDurationEntries.data(), dynamicDepthMinDurationEntries.size());
771 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,
772 dynamicDepthStallDurationEntries.data(), dynamicDepthStallDurationEntries.size());
773
774 std::vector<int32_t> supportedChTags;
775 supportedChTags.reserve(chTags.count + 3);
776 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
777 chTags.data.i32 + chTags.count);
778 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
779 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS);
780 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS);
781 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
782 supportedChTags.size());
783
784 return OK;
785}
786
Shuzhen Wang268a1362018-10-16 16:32:59 -0700787status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
788 status_t res = OK;
789 auto& c = mCameraCharacteristics;
790
791 // Override static metadata for MONOCHROME camera with older device version
792 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
793 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
794 for (size_t i = 0; i < cap.count; i++) {
795 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
796 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
797 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
798 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
799 if (res != OK) {
800 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
801 __FUNCTION__, strerror(-res), res);
802 return res;
803 }
804
805 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
806 const std::vector<uint32_t> sKeys = {
807 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
808 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
809 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
810 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
811 ANDROID_SENSOR_COLOR_TRANSFORM1,
812 ANDROID_SENSOR_COLOR_TRANSFORM2,
813 ANDROID_SENSOR_FORWARD_MATRIX1,
814 ANDROID_SENSOR_FORWARD_MATRIX2,
815 };
816 res = removeAvailableKeys(c, sKeys,
817 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
818 if (res != OK) {
819 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
820 __FUNCTION__, strerror(-res), res);
821 return res;
822 }
823
824 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
825 const std::vector<uint32_t> reqKeys = {
826 ANDROID_COLOR_CORRECTION_MODE,
827 ANDROID_COLOR_CORRECTION_TRANSFORM,
828 ANDROID_COLOR_CORRECTION_GAINS,
829 };
830 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
831 if (res != OK) {
832 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
833 __FUNCTION__, strerror(-res), res);
834 return res;
835 }
836
837 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
838 const std::vector<uint32_t> resKeys = {
839 ANDROID_SENSOR_GREEN_SPLIT,
840 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
841 ANDROID_COLOR_CORRECTION_MODE,
842 ANDROID_COLOR_CORRECTION_TRANSFORM,
843 ANDROID_COLOR_CORRECTION_GAINS,
844 };
845 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
846 if (res != OK) {
847 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
848 __FUNCTION__, strerror(-res), res);
849 return res;
850 }
851
852 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
853 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
854 for (size_t j = 1; j < blEntry.count; j++) {
855 blEntry.data.i32[j] = blEntry.data.i32[0];
856 }
857 }
858 }
859 }
860 return res;
861}
862
863status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
864 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
865 status_t res = OK;
866
867 camera_metadata_entry keysEntry = c.find(keyTag);
868 if (keysEntry.count == 0) {
869 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
870 return res;
871 }
872 std::vector<int32_t> vKeys;
873 vKeys.reserve(keysEntry.count);
874 for (size_t i = 0; i < keysEntry.count; i++) {
875 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
876 vKeys.push_back(keysEntry.data.i32[i]);
877 }
878 }
879 res = c.update(keyTag, vKeys.data(), vKeys.size());
880 return res;
881}
882
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700883bool CameraProviderManager::isLogicalCamera(const std::string& id,
884 std::vector<std::string>* physicalCameraIds) {
885 std::lock_guard<std::mutex> lock(mInterfaceMutex);
886
887 auto deviceInfo = findDeviceInfoLocked(id);
888 if (deviceInfo == nullptr) return false;
889
890 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
891 *physicalCameraIds = deviceInfo->mPhysicalIds;
892 }
893 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700894}
895
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800896bool CameraProviderManager::isPublicallyHiddenSecureCamera(const std::string& id) {
897 std::lock_guard<std::mutex> lock(mInterfaceMutex);
898
899 auto deviceInfo = findDeviceInfoLocked(id);
900 if (deviceInfo == nullptr) {
901 return false;
902 }
903 return deviceInfo->mIsPublicallyHiddenSecureCamera;
904}
905
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700906bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) {
907 for (auto& provider : mProviders) {
908 for (auto& deviceInfo : provider->mDevices) {
909 if (deviceInfo->mId == cameraId) {
910 // cameraId is found in public camera IDs advertised by the
911 // provider.
912 return false;
913 }
914 }
915 }
916
917 for (auto& provider : mProviders) {
918 for (auto& deviceInfo : provider->mDevices) {
919 CameraMetadata info;
920 status_t res = deviceInfo->getCameraCharacteristics(&info);
921 if (res != OK) {
922 ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
923 deviceInfo->mId.c_str());
924 return false;
925 }
926
927 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700928 if (deviceInfo->mIsLogicalCamera) {
929 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
930 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700931 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
932 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
933 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
934 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
935 __FUNCTION__, deviceVersion, cameraId.c_str());
936 return false;
937 } else {
938 return true;
939 }
940 }
941 }
942 }
943 }
944
945 return false;
946}
947
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700948status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800949 for (const auto& providerInfo : mProviders) {
950 if (providerInfo->mProviderName == newProvider) {
951 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
952 newProvider.c_str());
953 return ALREADY_EXISTS;
954 }
955 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700956
957 sp<provider::V2_4::ICameraProvider> interface;
958 interface = mServiceProxy->getService(newProvider);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800959
960 if (interface == nullptr) {
961 if (expected) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700962 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
963 newProvider.c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800964 return BAD_VALUE;
965 } else {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800966 return OK;
967 }
968 }
969
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700970 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
971 status_t res = providerInfo->initialize(interface);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800972 if (res != OK) {
973 return res;
974 }
975
976 mProviders.push_back(providerInfo);
977
978 return OK;
979}
980
981status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700982 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700983 std::unique_lock<std::mutex> lock(mInterfaceMutex);
984 std::vector<String8> removedDeviceIds;
985 status_t res = NAME_NOT_FOUND;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800986 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
987 if ((*it)->mProviderName == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700988 removedDeviceIds.reserve((*it)->mDevices.size());
989 for (auto& deviceInfo : (*it)->mDevices) {
990 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
991 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800992 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700993 res = OK;
994 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800995 }
996 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700997 if (res != OK) {
998 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
999 provider.c_str());
1000 } else {
1001 // Inform camera service of loss of presence for all the devices from this provider,
1002 // without lock held for reentrancy
1003 sp<StatusListener> listener = getStatusListener();
1004 if (listener != nullptr) {
1005 lock.unlock();
1006 for (auto& id : removedDeviceIds) {
1007 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1008 }
1009 }
1010 }
1011 return res;
1012}
1013
1014sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1015 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001016}
1017
1018/**** Methods for ProviderInfo ****/
1019
1020
1021CameraProviderManager::ProviderInfo::ProviderInfo(
1022 const std::string &providerName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001023 CameraProviderManager *manager) :
1024 mProviderName(providerName),
Emilian Peev71c73a22017-03-21 16:35:51 +00001025 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001026 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001027 mManager(manager) {
1028 (void) mManager;
1029}
1030
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001031status_t CameraProviderManager::ProviderInfo::initialize(
1032 sp<provider::V2_4::ICameraProvider>& interface) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001033 status_t res = parseProviderName(mProviderName, &mType, &mId);
1034 if (res != OK) {
1035 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1036 return BAD_VALUE;
1037 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001038 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001039 mProviderName.c_str(), interface->isRemote());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001040 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1041 // before setCallback returns
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001042 hardware::Return<Status> status = interface->setCallback(this);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001043 if (!status.isOk()) {
1044 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1045 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1046 return DEAD_OBJECT;
1047 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001048 if (status != Status::OK) {
1049 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1050 __FUNCTION__, mProviderName.c_str());
1051 return mapToStatusT(status);
1052 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001053
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001054 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001055 if (!linked.isOk()) {
1056 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1057 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1058 return DEAD_OBJECT;
1059 } else if (!linked) {
1060 ALOGW("%s: Unable to link to provider '%s' death notifications",
1061 __FUNCTION__, mProviderName.c_str());
1062 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001063
1064 // Get initial list of camera devices, if any
1065 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001066 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001067 Status idStatus,
1068 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1069 status = idStatus;
1070 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001071 for (auto& name : cameraDeviceNames) {
1072 uint16_t major, minor;
1073 std::string type, id;
1074 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1075 if (res != OK) {
1076 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1077 status = Status::INTERNAL_ERROR;
1078 } else {
1079 devices.push_back(name);
1080 mProviderPublicCameraIds.push_back(id);
1081 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001082 }
1083 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001084 if (!ret.isOk()) {
1085 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1086 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1087 return DEAD_OBJECT;
1088 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001089 if (status != Status::OK) {
1090 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1091 __FUNCTION__, mProviderName.c_str());
1092 return mapToStatusT(status);
1093 }
1094
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001095 ret = interface->isSetTorchModeSupported(
1096 [this](auto status, bool supported) {
1097 if (status == Status::OK) {
1098 mSetTorchModeSupported = supported;
1099 }
1100 });
1101 if (!ret.isOk()) {
1102 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1103 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1104 return DEAD_OBJECT;
1105 }
1106
1107 mIsRemote = interface->isRemote();
1108
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001109 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001110 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001111 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001112 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001113 if (res != OK) {
1114 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1115 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001116 continue;
1117 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001118 }
1119
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001120 res = setUpVendorTags();
1121 if (res != OK) {
1122 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1123 __FUNCTION__, mProviderName.c_str());
1124 return res;
1125 }
1126
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001127 ALOGI("Camera provider %s ready with %zu camera devices",
1128 mProviderName.c_str(), mDevices.size());
1129
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001130 mInitialized = true;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001131 if (!kEnableLazyHal) {
1132 // Save HAL reference indefinitely
1133 mSavedInterface = interface;
1134 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001135 return OK;
1136}
1137
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001138const sp<provider::V2_4::ICameraProvider>
1139CameraProviderManager::ProviderInfo::startProviderInterface() {
1140 ATRACE_CALL();
1141 ALOGI("Request to start camera provider: %s", mProviderName.c_str());
1142 if (mSavedInterface != nullptr) {
1143 return mSavedInterface;
1144 }
1145 auto interface = mActiveInterface.promote();
1146 if (interface == nullptr) {
1147 ALOGI("Could not promote, calling getService(%s)", mProviderName.c_str());
1148 interface = mManager->mServiceProxy->getService(mProviderName);
1149 interface->setCallback(this);
1150 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
1151 if (!linked.isOk()) {
1152 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1153 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1154 mManager->removeProvider(mProviderName);
1155 return nullptr;
1156 } else if (!linked) {
1157 ALOGW("%s: Unable to link to provider '%s' death notifications",
1158 __FUNCTION__, mProviderName.c_str());
1159 }
1160 mActiveInterface = interface;
1161 } else {
1162 ALOGI("Camera provider (%s) already in use. Re-using instance.", mProviderName.c_str());
1163 }
1164 return interface;
1165}
1166
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001167const std::string& CameraProviderManager::ProviderInfo::getType() const {
1168 return mType;
1169}
1170
1171status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1172 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1173
1174 ALOGI("Enumerating new camera device: %s", name.c_str());
1175
1176 uint16_t major, minor;
1177 std::string type, id;
1178
1179 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1180 if (res != OK) {
1181 return res;
1182 }
1183 if (type != mType) {
1184 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1185 type.c_str(), mType.c_str());
1186 return BAD_VALUE;
1187 }
1188 if (mManager->isValidDeviceLocked(id, major)) {
1189 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1190 name.c_str(), id.c_str(), major);
1191 return BAD_VALUE;
1192 }
1193
1194 std::unique_ptr<DeviceInfo> deviceInfo;
1195 switch (major) {
1196 case 1:
Emilian Peev71c73a22017-03-21 16:35:51 +00001197 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
1198 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001199 break;
1200 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001201 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1202 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001203 break;
1204 default:
1205 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1206 name.c_str(), major);
1207 return BAD_VALUE;
1208 }
1209 if (deviceInfo == nullptr) return BAD_VALUE;
1210 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001211 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001212
1213 mDevices.push_back(std::move(deviceInfo));
1214
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001215 mUniqueCameraIds.insert(id);
1216 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001217 // addDevice can be called more than once for the same camera id if HAL
1218 // supports openLegacy.
1219 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1220 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1221 mUniqueAPI1CompatibleCameraIds.push_back(id);
1222 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001223 }
1224
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001225 if (parsedId != nullptr) {
1226 *parsedId = id;
1227 }
1228 return OK;
1229}
1230
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001231void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1232 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1233 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001234 mUniqueCameraIds.erase(id);
1235 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001236 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
1237 mUniqueAPI1CompatibleCameraIds.begin(),
1238 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001239 }
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001240 mDevices.erase(it);
1241 break;
1242 }
1243 }
1244}
1245
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001246status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001247 dprintf(fd, "== Camera Provider HAL %s (v2.4, %s) static info: %zu devices: ==\n",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001248 mProviderName.c_str(), mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001249 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001250
1251 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001252 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1253 device->mVersion.get_major(), device->mVersion.get_minor());
1254 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1255 if (device->mResourceCost.conflictingDevices.size() == 0) {
1256 dprintf(fd, " Conflicting devices: None\n");
1257 } else {
1258 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001259 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001260 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001261 device->mResourceCost.conflictingDevices[i].c_str());
1262 }
1263 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001264 dprintf(fd, " API1 info:\n");
1265 dprintf(fd, " Has a flash unit: %s\n",
1266 device->hasFlashUnit() ? "true" : "false");
1267 hardware::CameraInfo info;
1268 status_t res = device->getCameraInfo(&info);
1269 if (res != OK) {
1270 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1271 strerror(-res), res);
1272 } else {
1273 dprintf(fd, " Facing: %s\n",
1274 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1275 dprintf(fd, " Orientation: %d\n", info.orientation);
1276 }
1277 CameraMetadata info2;
1278 res = device->getCameraCharacteristics(&info2);
1279 if (res == INVALID_OPERATION) {
1280 dprintf(fd, " API2 not directly supported\n");
1281 } else if (res != OK) {
1282 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1283 strerror(-res), res);
1284 } else {
1285 dprintf(fd, " API2 camera characteristics:\n");
1286 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1287 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001288
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001289 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001290 if (device->mIsLogicalCamera) {
1291 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001292 // Skip if physical id is an independent camera
1293 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1294 != mProviderPublicCameraIds.end()) {
1295 continue;
1296 }
1297
1298 CameraMetadata physicalInfo;
1299 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1300 if (status == OK) {
1301 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1302 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1303 }
1304 }
1305 }
1306
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001307 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1308 device->mVersion.get_major(), device->mVersion.get_minor());
1309 res = device->dumpState(fd);
1310 if (res != OK) {
1311 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1312 device->mName.c_str(), strerror(-res), res);
1313 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001314 }
1315 return OK;
1316}
1317
1318hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1319 const hardware::hidl_string& cameraDeviceName,
1320 CameraDeviceStatus newStatus) {
1321 sp<StatusListener> listener;
1322 std::string id;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001323 bool initialized = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001324 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001325 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001326 bool known = false;
1327 for (auto& deviceInfo : mDevices) {
1328 if (deviceInfo->mName == cameraDeviceName) {
1329 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
1330 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
1331 deviceInfo->mStatus = newStatus;
1332 // TODO: Handle device removal (NOT_PRESENT)
1333 id = deviceInfo->mId;
1334 known = true;
1335 break;
1336 }
1337 }
1338 // Previously unseen device; status must not be NOT_PRESENT
1339 if (!known) {
1340 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1341 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
1342 mProviderName.c_str(), cameraDeviceName.c_str());
1343 return hardware::Void();
1344 }
1345 addDevice(cameraDeviceName, newStatus, &id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001346 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1347 removeDevice(id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001348 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001349 listener = mManager->getStatusListener();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001350 initialized = mInitialized;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001351 }
1352 // Call without lock held to allow reentrancy into provider manager
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001353 // Don't send the callback if providerInfo hasn't been initialized.
1354 // CameraService will initialize device status after provider is
1355 // initialized
1356 if (listener != nullptr && initialized) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001357 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
1358 }
1359 return hardware::Void();
1360}
1361
1362hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
1363 const hardware::hidl_string& cameraDeviceName,
1364 TorchModeStatus newStatus) {
1365 sp<StatusListener> listener;
1366 std::string id;
1367 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001368 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001369 bool known = false;
1370 for (auto& deviceInfo : mDevices) {
1371 if (deviceInfo->mName == cameraDeviceName) {
1372 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
1373 torchStatusToString(newStatus));
1374 id = deviceInfo->mId;
1375 known = true;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001376 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
1377 mManager->removeRef(DeviceMode::TORCH, id);
1378 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001379 break;
1380 }
1381 }
1382 if (!known) {
1383 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
1384 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
1385 return hardware::Void();
1386 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001387 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001388 }
1389 // Call without lock held to allow reentrancy into provider manager
1390 if (listener != nullptr) {
1391 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
1392 }
1393 return hardware::Void();
1394}
1395
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001396void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
1397 const wp<hidl::base::V1_0::IBase>& who) {
1398 (void) who;
1399 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
1400 if (cookie != mId) {
1401 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
1402 __FUNCTION__, cookie, mId);
1403 }
1404 mManager->removeProvider(mProviderName);
1405}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001406
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001407status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
1408 if (mVendorTagDescriptor != nullptr)
1409 return OK;
1410
1411 hardware::hidl_vec<VendorTagSection> vts;
1412 Status status;
1413 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001414 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1415 if (interface == nullptr) {
1416 return DEAD_OBJECT;
1417 }
1418 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001419 [&](auto s, const auto& vendorTagSecs) {
1420 status = s;
1421 if (s == Status::OK) {
1422 vts = vendorTagSecs;
1423 }
1424 });
1425 if (!ret.isOk()) {
1426 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
1427 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1428 return DEAD_OBJECT;
1429 }
1430 if (status != Status::OK) {
1431 return mapToStatusT(status);
1432 }
1433
1434 // Read all vendor tag definitions into a descriptor
1435 status_t res;
1436 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
1437 != OK) {
1438 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
1439 "received error %s (%d). Camera clients will not be able to use"
1440 "vendor tags", __FUNCTION__, strerror(res), res);
1441 return res;
1442 }
1443
1444 return OK;
1445}
1446
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001447template<class DeviceInfoT>
1448std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
1449 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00001450 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001451 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001452 Status status;
1453
1454 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001455 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001456 if (cameraInterface == nullptr) return nullptr;
1457
1458 CameraResourceCost resourceCost;
1459 cameraInterface->getResourceCost([&status, &resourceCost](
1460 Status s, CameraResourceCost cost) {
1461 status = s;
1462 resourceCost = cost;
1463 });
1464 if (status != Status::OK) {
1465 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
1466 name.c_str(), statusToString(status));
1467 return nullptr;
1468 }
Shuzhen Wang47283692018-04-24 18:05:02 -07001469
1470 for (auto& conflictName : resourceCost.conflictingDevices) {
1471 uint16_t major, minor;
1472 std::string type, id;
1473 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
1474 if (res != OK) {
1475 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
1476 return nullptr;
1477 }
1478 conflictName = id;
1479 }
1480
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001481 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001482 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001483 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001484}
1485
1486template<class InterfaceT>
1487sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001488CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001489 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1490 name.c_str(), InterfaceT::version.get_major());
1491 return nullptr;
1492}
1493
1494template<>
1495sp<device::V1_0::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001496CameraProviderManager::ProviderInfo::startDeviceInterface
1497 <device::V1_0::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001498 Status status;
1499 sp<device::V1_0::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001500 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001501 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1502 if (interface == nullptr) {
1503 return nullptr;
1504 }
1505 ret = interface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001506 Status s, sp<device::V1_0::ICameraDevice> interface) {
1507 status = s;
1508 cameraInterface = interface;
1509 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001510 if (!ret.isOk()) {
1511 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1512 __FUNCTION__, name.c_str(), ret.description().c_str());
1513 return nullptr;
1514 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001515 if (status != Status::OK) {
1516 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1517 name.c_str(), statusToString(status));
1518 return nullptr;
1519 }
1520 return cameraInterface;
1521}
1522
1523template<>
1524sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001525CameraProviderManager::ProviderInfo::startDeviceInterface
1526 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001527 Status status;
1528 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001529 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001530 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1531 if (interface == nullptr) {
1532 return nullptr;
1533 }
1534 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001535 Status s, sp<device::V3_2::ICameraDevice> interface) {
1536 status = s;
1537 cameraInterface = interface;
1538 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001539 if (!ret.isOk()) {
1540 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1541 __FUNCTION__, name.c_str(), ret.description().c_str());
1542 return nullptr;
1543 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001544 if (status != Status::OK) {
1545 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1546 name.c_str(), statusToString(status));
1547 return nullptr;
1548 }
1549 return cameraInterface;
1550}
1551
1552CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
1553
1554template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001555sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
1556 sp<InterfaceT> device;
1557 ATRACE_CALL();
1558 if (mSavedInterface == nullptr) {
1559 device = mParentProvider->startDeviceInterface<InterfaceT>(mName);
1560 } else {
1561 device = (InterfaceT *) mSavedInterface.get();
1562 }
1563 return device;
1564}
1565
1566template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001567status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
1568 bool enabled) {
1569 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
1570 return mapToStatusT(s);
1571}
1572
1573CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001574 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001575 uint16_t minorVersion,
1576 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001577 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001578 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001579 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001580 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001581 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001582 // Get default parameters and initialize flash unit availability
1583 // Requires powering on the camera device
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001584 hardware::Return<Status> status = interface->open(nullptr);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001585 if (!status.isOk()) {
1586 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001587 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001588 return;
1589 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001590 if (status != Status::OK) {
1591 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001592 id.c_str(), CameraProviderManager::statusToString(status));
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001593 return;
1594 }
1595 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001596 ret = interface->getParameters([this](const hardware::hidl_string& parms) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001597 mDefaultParameters.unflatten(String8(parms.c_str()));
1598 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001599 if (!ret.isOk()) {
1600 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001601 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001602 return;
1603 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001604 const char *flashMode =
1605 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1606 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
1607 mHasFlashUnit = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001608 }
1609
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001610 status_t res = cacheCameraInfo(interface);
1611 if (res != OK) {
1612 ALOGE("%s: Could not cache CameraInfo", __FUNCTION__);
1613 return;
1614 }
1615
1616 ret = interface->close();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001617 if (!ret.isOk()) {
1618 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001619 __FUNCTION__, id.c_str(), status.description().c_str());
1620 }
1621
1622 if (!kEnableLazyHal) {
1623 // Save HAL reference indefinitely
1624 mSavedInterface = interface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001625 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001626}
1627
1628CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
1629
1630status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001631 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001632}
1633
1634status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
1635 hardware::CameraInfo *info) const {
1636 if (info == nullptr) return BAD_VALUE;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001637 *info = mInfo;
1638 return OK;
1639}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001640
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001641status_t CameraProviderManager::ProviderInfo::DeviceInfo1::cacheCameraInfo(
1642 sp<CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT> interface) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001643 Status status;
1644 device::V1_0::CameraInfo cInfo;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001645 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001646 ret = interface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001647 status = s;
1648 cInfo = camInfo;
1649 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001650 if (!ret.isOk()) {
1651 ALOGE("%s: Transaction error reading camera info from device %s: %s",
1652 __FUNCTION__, mId.c_str(), ret.description().c_str());
1653 return DEAD_OBJECT;
1654 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001655 if (status != Status::OK) {
1656 return mapToStatusT(status);
1657 }
1658
1659 switch(cInfo.facing) {
1660 case device::V1_0::CameraFacing::BACK:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001661 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001662 break;
1663 case device::V1_0::CameraFacing::EXTERNAL:
1664 // Map external to front for legacy API
1665 case device::V1_0::CameraFacing::FRONT:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001666 mInfo.facing = hardware::CAMERA_FACING_FRONT;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001667 break;
1668 default:
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001669 ALOGW("%s: Device %s: Unknown camera facing: %d",
1670 __FUNCTION__, mId.c_str(), cInfo.facing);
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001671 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001672 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001673 mInfo.orientation = cInfo.orientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001674
1675 return OK;
1676}
1677
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001678status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001679 native_handle_t* handle = native_handle_create(1,0);
1680 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001681 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1682 if (interface == nullptr) {
1683 return DEAD_OBJECT;
1684 }
1685 hardware::Return<Status> s = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001686 native_handle_delete(handle);
1687 if (!s.isOk()) {
1688 return INVALID_OPERATION;
1689 }
1690 return mapToStatusT(s);
1691}
1692
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001693CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001694 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001695 uint16_t minorVersion,
1696 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001697 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001698 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001699 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001700 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001701 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001702 // Get camera characteristics and initialize flash unit availability
1703 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001704 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001705 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001706 device::V3_2::CameraMetadata metadata) {
1707 status = s;
1708 if (s == Status::OK) {
1709 camera_metadata_t *buffer =
1710 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07001711 size_t expectedSize = metadata.size();
1712 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1713 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1714 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1715 mCameraCharacteristics = buffer;
1716 } else {
1717 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1718 status = Status::INTERNAL_ERROR;
1719 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001720 }
1721 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001722 if (!ret.isOk()) {
1723 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001724 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001725 ret.description().c_str());
1726 return;
1727 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001728 if (status != Status::OK) {
1729 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001730 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001731 return;
1732 }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001733
1734 mIsPublicallyHiddenSecureCamera = isPublicallyHiddenSecureCamera();
1735
Shuzhen Wang268a1362018-10-16 16:32:59 -07001736 status_t res = fixupMonochromeTags();
1737 if (OK != res) {
1738 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
1739 __FUNCTION__, strerror(-res), res);
1740 return;
1741 }
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001742 res = addDynamicDepthTags();
1743 if (OK != res) {
1744 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-res),
1745 res);
1746 return;
1747 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001748 camera_metadata_entry flashAvailable =
1749 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
1750 if (flashAvailable.count == 1 &&
1751 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
1752 mHasFlashUnit = true;
1753 } else {
1754 mHasFlashUnit = false;
1755 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001756
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001757 queryPhysicalCameraIds();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001758
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001759 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001760 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001761 if (!castResult.isOk()) {
1762 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
1763 return;
1764 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001765 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001766 if (interface_3_5 == nullptr) {
1767 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
1768 return;
1769 }
1770
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001771 if (mIsLogicalCamera) {
1772 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001773 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
1774 mPublicCameraIds.end()) {
1775 continue;
1776 }
1777
1778 hardware::hidl_string hidlId(id);
1779 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
1780 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
1781 status = s;
1782 if (s == Status::OK) {
1783 camera_metadata_t *buffer =
1784 reinterpret_cast<camera_metadata_t*>(metadata.data());
1785 size_t expectedSize = metadata.size();
1786 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1787 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1788 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1789 mPhysicalCameraCharacteristics[id] = buffer;
1790 } else {
1791 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1792 status = Status::INTERNAL_ERROR;
1793 }
1794 }
1795 });
1796
1797 if (!ret.isOk()) {
1798 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001799 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001800 return;
1801 }
1802 if (status != Status::OK) {
1803 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
1804 __FUNCTION__, id.c_str(), mId.c_str(),
1805 CameraProviderManager::statusToString(status), status);
1806 return;
1807 }
1808 }
1809 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001810
1811 if (!kEnableLazyHal) {
1812 // Save HAL reference indefinitely
1813 mSavedInterface = interface;
1814 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001815}
1816
1817CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
1818
1819status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001820 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001821}
1822
1823status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
1824 hardware::CameraInfo *info) const {
1825 if (info == nullptr) return BAD_VALUE;
1826
1827 camera_metadata_ro_entry facing =
1828 mCameraCharacteristics.find(ANDROID_LENS_FACING);
1829 if (facing.count == 1) {
1830 switch (facing.data.u8[0]) {
1831 case ANDROID_LENS_FACING_BACK:
1832 info->facing = hardware::CAMERA_FACING_BACK;
1833 break;
1834 case ANDROID_LENS_FACING_EXTERNAL:
1835 // Map external to front for legacy API
1836 case ANDROID_LENS_FACING_FRONT:
1837 info->facing = hardware::CAMERA_FACING_FRONT;
1838 break;
1839 }
1840 } else {
1841 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
1842 return NAME_NOT_FOUND;
1843 }
1844
1845 camera_metadata_ro_entry orientation =
1846 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
1847 if (orientation.count == 1) {
1848 info->orientation = orientation.data.i32[0];
1849 } else {
1850 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
1851 return NAME_NOT_FOUND;
1852 }
1853
1854 return OK;
1855}
Emilian Peevf53f66e2017-04-11 14:29:43 +01001856bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
1857 bool isBackwardCompatible = false;
1858 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
1859 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1860 for (size_t i = 0; i < caps.count; i++) {
1861 if (caps.data.u8[i] ==
1862 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
1863 isBackwardCompatible = true;
1864 break;
1865 }
1866 }
1867
1868 return isBackwardCompatible;
1869}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001870
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001871status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001872 native_handle_t* handle = native_handle_create(1,0);
1873 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001874 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1875 if (interface == nullptr) {
1876 return DEAD_OBJECT;
1877 }
1878 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001879 native_handle_delete(handle);
1880 if (!ret.isOk()) {
1881 return INVALID_OPERATION;
1882 }
1883 return OK;
1884}
1885
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001886status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
1887 CameraMetadata *characteristics) const {
1888 if (characteristics == nullptr) return BAD_VALUE;
1889
1890 *characteristics = mCameraCharacteristics;
1891 return OK;
1892}
1893
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001894status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
1895 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
1896 if (characteristics == nullptr) return BAD_VALUE;
1897 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
1898 mPhysicalCameraCharacteristics.end()) {
1899 return NAME_NOT_FOUND;
1900 }
1901
1902 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
1903 return OK;
1904}
1905
Emilian Peev35ae8262018-11-08 13:11:32 +00001906status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
1907 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001908 bool *status /*out*/) {
1909
1910 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
1911 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
1912 if (interface == nullptr) {
1913 return DEAD_OBJECT;
1914 }
1915 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Emilian Peev35ae8262018-11-08 13:11:32 +00001916 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
1917 if (interface_3_5 == nullptr) {
1918 return INVALID_OPERATION;
1919 }
1920
1921 status_t res;
1922 Status callStatus;
1923 auto ret = interface_3_5->isStreamCombinationSupported(configuration,
1924 [&callStatus, &status] (Status s, bool combStatus) {
1925 callStatus = s;
1926 *status = combStatus;
1927 });
1928 if (ret.isOk()) {
1929 switch (callStatus) {
1930 case Status::OK:
1931 // Expected case, do nothing.
1932 res = OK;
1933 break;
1934 case Status::METHOD_NOT_SUPPORTED:
1935 res = INVALID_OPERATION;
1936 break;
1937 default:
1938 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
1939 res = UNKNOWN_ERROR;
1940 }
1941 } else {
1942 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
1943 res = UNKNOWN_ERROR;
1944 }
1945
1946 return res;
1947}
1948
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001949status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
1950 std::string *type, uint32_t *id) {
1951 // Format must be "<type>/<id>"
1952#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
1953 "Should match '<type>/<id>' - "
1954
1955 if (!type || !id) return INVALID_OPERATION;
1956
1957 std::string::size_type slashIdx = name.find('/');
1958 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
1959 ALOGE(ERROR_MSG_PREFIX
1960 "does not have / separator between type and id",
1961 __FUNCTION__, name.c_str());
1962 return BAD_VALUE;
1963 }
1964
1965 std::string typeVal = name.substr(0, slashIdx);
1966
1967 char *endPtr;
1968 errno = 0;
1969 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
1970 if (errno != 0) {
1971 ALOGE(ERROR_MSG_PREFIX
1972 "cannot parse provider id as an integer: %s (%d)",
1973 __FUNCTION__, name.c_str(), strerror(errno), errno);
1974 return BAD_VALUE;
1975 }
1976 if (endPtr != name.c_str() + name.size()) {
1977 ALOGE(ERROR_MSG_PREFIX
1978 "provider id has unexpected length",
1979 __FUNCTION__, name.c_str());
1980 return BAD_VALUE;
1981 }
1982 if (idVal < 0) {
1983 ALOGE(ERROR_MSG_PREFIX
1984 "id is negative: %ld",
1985 __FUNCTION__, name.c_str(), idVal);
1986 return BAD_VALUE;
1987 }
1988
1989#undef ERROR_MSG_PREFIX
1990
1991 *type = typeVal;
1992 *id = static_cast<uint32_t>(idVal);
1993
1994 return OK;
1995}
1996
Emilian Peev71c73a22017-03-21 16:35:51 +00001997metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
1998 const std::string &name) {
1999 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
2000 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
2001 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
2002 ret = 0;
2003 }
2004
2005 return ret;
2006}
2007
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002008status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
2009 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
2010
2011 // Format must be "device@<major>.<minor>/<type>/<id>"
2012
2013#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
2014 "Should match 'device@<major>.<minor>/<type>/<id>' - "
2015
2016 if (!major || !minor || !type || !id) return INVALID_OPERATION;
2017
2018 // Verify starting prefix
2019 const char expectedPrefix[] = "device@";
2020
2021 if (name.find(expectedPrefix) != 0) {
2022 ALOGE(ERROR_MSG_PREFIX
2023 "does not start with '%s'",
2024 __FUNCTION__, name.c_str(), expectedPrefix);
2025 return BAD_VALUE;
2026 }
2027
2028 // Extract major/minor versions
2029 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
2030 std::string::size_type dotIdx = name.find('.', atIdx);
2031 if (dotIdx == std::string::npos) {
2032 ALOGE(ERROR_MSG_PREFIX
2033 "does not have @<major>. version section",
2034 __FUNCTION__, name.c_str());
2035 return BAD_VALUE;
2036 }
2037 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
2038 if (typeSlashIdx == std::string::npos) {
2039 ALOGE(ERROR_MSG_PREFIX
2040 "does not have .<minor>/ version section",
2041 __FUNCTION__, name.c_str());
2042 return BAD_VALUE;
2043 }
2044
2045 char *endPtr;
2046 errno = 0;
2047 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
2048 if (errno != 0) {
2049 ALOGE(ERROR_MSG_PREFIX
2050 "cannot parse major version: %s (%d)",
2051 __FUNCTION__, name.c_str(), strerror(errno), errno);
2052 return BAD_VALUE;
2053 }
2054 if (endPtr != name.c_str() + dotIdx) {
2055 ALOGE(ERROR_MSG_PREFIX
2056 "major version has unexpected length",
2057 __FUNCTION__, name.c_str());
2058 return BAD_VALUE;
2059 }
2060 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
2061 if (errno != 0) {
2062 ALOGE(ERROR_MSG_PREFIX
2063 "cannot parse minor version: %s (%d)",
2064 __FUNCTION__, name.c_str(), strerror(errno), errno);
2065 return BAD_VALUE;
2066 }
2067 if (endPtr != name.c_str() + typeSlashIdx) {
2068 ALOGE(ERROR_MSG_PREFIX
2069 "minor version has unexpected length",
2070 __FUNCTION__, name.c_str());
2071 return BAD_VALUE;
2072 }
2073 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
2074 ALOGE(ERROR_MSG_PREFIX
2075 "major/minor version is out of range of uint16_t: %ld.%ld",
2076 __FUNCTION__, name.c_str(), majorVal, minorVal);
2077 return BAD_VALUE;
2078 }
2079
2080 // Extract type and id
2081
2082 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
2083 if (instanceSlashIdx == std::string::npos) {
2084 ALOGE(ERROR_MSG_PREFIX
2085 "does not have /<type>/ component",
2086 __FUNCTION__, name.c_str());
2087 return BAD_VALUE;
2088 }
2089 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
2090
2091 if (instanceSlashIdx == name.size() - 1) {
2092 ALOGE(ERROR_MSG_PREFIX
2093 "does not have an /<id> component",
2094 __FUNCTION__, name.c_str());
2095 return BAD_VALUE;
2096 }
2097 std::string idVal = name.substr(instanceSlashIdx + 1);
2098
2099#undef ERROR_MSG_PREFIX
2100
2101 *major = static_cast<uint16_t>(majorVal);
2102 *minor = static_cast<uint16_t>(minorVal);
2103 *type = typeVal;
2104 *id = idVal;
2105
2106 return OK;
2107}
2108
2109
2110
2111CameraProviderManager::ProviderInfo::~ProviderInfo() {
2112 // Destruction of ProviderInfo is only supposed to happen when the respective
2113 // CameraProvider interface dies, so do not unregister callbacks.
2114
2115}
2116
2117status_t CameraProviderManager::mapToStatusT(const Status& s) {
2118 switch(s) {
2119 case Status::OK:
2120 return OK;
2121 case Status::ILLEGAL_ARGUMENT:
2122 return BAD_VALUE;
2123 case Status::CAMERA_IN_USE:
2124 return -EBUSY;
2125 case Status::MAX_CAMERAS_IN_USE:
2126 return -EUSERS;
2127 case Status::METHOD_NOT_SUPPORTED:
2128 return UNKNOWN_TRANSACTION;
2129 case Status::OPERATION_NOT_SUPPORTED:
2130 return INVALID_OPERATION;
2131 case Status::CAMERA_DISCONNECTED:
2132 return DEAD_OBJECT;
2133 case Status::INTERNAL_ERROR:
2134 return INVALID_OPERATION;
2135 }
2136 ALOGW("Unexpected HAL status code %d", s);
2137 return INVALID_OPERATION;
2138}
2139
2140const char* CameraProviderManager::statusToString(const Status& s) {
2141 switch(s) {
2142 case Status::OK:
2143 return "OK";
2144 case Status::ILLEGAL_ARGUMENT:
2145 return "ILLEGAL_ARGUMENT";
2146 case Status::CAMERA_IN_USE:
2147 return "CAMERA_IN_USE";
2148 case Status::MAX_CAMERAS_IN_USE:
2149 return "MAX_CAMERAS_IN_USE";
2150 case Status::METHOD_NOT_SUPPORTED:
2151 return "METHOD_NOT_SUPPORTED";
2152 case Status::OPERATION_NOT_SUPPORTED:
2153 return "OPERATION_NOT_SUPPORTED";
2154 case Status::CAMERA_DISCONNECTED:
2155 return "CAMERA_DISCONNECTED";
2156 case Status::INTERNAL_ERROR:
2157 return "INTERNAL_ERROR";
2158 }
2159 ALOGW("Unexpected HAL status code %d", s);
2160 return "UNKNOWN_ERROR";
2161}
2162
2163const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
2164 switch(s) {
2165 case CameraDeviceStatus::NOT_PRESENT:
2166 return "NOT_PRESENT";
2167 case CameraDeviceStatus::PRESENT:
2168 return "PRESENT";
2169 case CameraDeviceStatus::ENUMERATING:
2170 return "ENUMERATING";
2171 }
2172 ALOGW("Unexpected HAL device status code %d", s);
2173 return "UNKNOWN_STATUS";
2174}
2175
2176const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
2177 switch(s) {
2178 case TorchModeStatus::NOT_AVAILABLE:
2179 return "NOT_AVAILABLE";
2180 case TorchModeStatus::AVAILABLE_OFF:
2181 return "AVAILABLE_OFF";
2182 case TorchModeStatus::AVAILABLE_ON:
2183 return "AVAILABLE_ON";
2184 }
2185 ALOGW("Unexpected HAL torch mode status code %d", s);
2186 return "UNKNOWN_STATUS";
2187}
2188
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002189
2190status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002191 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002192 /*out*/
2193 sp<VendorTagDescriptor>& descriptor) {
2194
2195 int tagCount = 0;
2196
2197 for (size_t s = 0; s < vts.size(); s++) {
2198 tagCount += vts[s].tags.size();
2199 }
2200
2201 if (tagCount < 0 || tagCount > INT32_MAX) {
2202 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
2203 return BAD_VALUE;
2204 }
2205
2206 Vector<uint32_t> tagArray;
2207 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
2208 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
2209
2210
2211 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
2212 desc->mTagCount = tagCount;
2213
2214 SortedVector<String8> sections;
2215 KeyedVector<uint32_t, String8> tagToSectionMap;
2216
2217 int idx = 0;
2218 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002219 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002220 const char *sectionName = section.sectionName.c_str();
2221 if (sectionName == NULL) {
2222 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
2223 return BAD_VALUE;
2224 }
2225 String8 sectionString(sectionName);
2226 sections.add(sectionString);
2227
2228 for (size_t j = 0; j < section.tags.size(); j++) {
2229 uint32_t tag = section.tags[j].tagId;
2230 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
2231 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
2232 return BAD_VALUE;
2233 }
2234
2235 tagArray.editItemAt(idx++) = section.tags[j].tagId;
2236
2237 const char *tagName = section.tags[j].tagName.c_str();
2238 if (tagName == NULL) {
2239 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
2240 return BAD_VALUE;
2241 }
2242 desc->mTagToNameMap.add(tag, String8(tagName));
2243 tagToSectionMap.add(tag, sectionString);
2244
2245 int tagType = (int) section.tags[j].tagType;
2246 if (tagType < 0 || tagType >= NUM_TYPES) {
2247 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
2248 return BAD_VALUE;
2249 }
2250 desc->mTagToTypeMap.add(tag, tagType);
2251 }
2252 }
2253
2254 desc->mSections = sections;
2255
2256 for (size_t i = 0; i < tagArray.size(); ++i) {
2257 uint32_t tag = tagArray[i];
2258 String8 sectionString = tagToSectionMap.valueFor(tag);
2259
2260 // Set up tag to section index map
2261 ssize_t index = sections.indexOf(sectionString);
2262 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
2263 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
2264
2265 // Set up reverse mapping
2266 ssize_t reverseIndex = -1;
2267 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
2268 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
2269 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
2270 }
2271 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
2272 }
2273
George Burgess IVa0b84962017-08-29 17:46:19 -07002274 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002275 return OK;
2276}
2277
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002278status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
2279 CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002280 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
2281 if (deviceInfo != nullptr) {
2282 return deviceInfo->getCameraCharacteristics(characteristics);
2283 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002284
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002285 // Find hidden physical camera characteristics
2286 for (auto& provider : mProviders) {
2287 for (auto& deviceInfo : provider->mDevices) {
2288 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
2289 if (res != NAME_NOT_FOUND) return res;
2290 }
2291 }
2292
2293 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002294}
2295
2296void CameraProviderManager::filterLogicalCameraIdsLocked(
2297 std::vector<std::string>& deviceIds) const
2298{
2299 std::unordered_set<std::string> removedIds;
2300
2301 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002302 auto deviceInfo = findDeviceInfoLocked(deviceId);
2303 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002304
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002305 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002306 continue;
2307 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002308 // idCombo contains the ids of a logical camera and its physical cameras
2309 std::vector<std::string> idCombo = deviceInfo->mPhysicalIds;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002310 idCombo.push_back(deviceId);
2311
2312 for (auto& id : deviceIds) {
2313 auto foundId = std::find(idCombo.begin(), idCombo.end(), id);
2314 if (foundId == idCombo.end()) {
2315 continue;
2316 }
2317
2318 idCombo.erase(foundId);
2319 removedIds.insert(idCombo.begin(), idCombo.end());
2320 break;
2321 }
2322 }
2323
2324 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
2325 [&removedIds](const std::string& s) {return removedIds.find(s) != removedIds.end();}),
2326 deviceIds.end());
2327}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002328
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002329} // namespace android