blob: c72029ff5a25edb9f5aee9302796fa4dad8f1410 [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>
Yin-Chia Yeh26c79972019-06-25 10:53:03 -070032#include <android/hidl/manager/1.2/IServiceManager.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080033#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000034#include <functional>
35#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080036#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070037#include <android-base/logging.h>
38#include <cutils/properties.h>
39#include <hwbinder/IPCThreadState.h>
40#include <utils/Trace.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080041
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080042#include "api2/HeicCompositeStream.h"
43
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080044namespace android {
45
46using namespace ::android::hardware::camera;
47using namespace ::android::hardware::camera::common::V1_0;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070048using std::literals::chrono_literals::operator""s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080049
50namespace {
Peter Kalauskasa29c1352018-10-10 12:05:42 -070051const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080052} // anonymous namespace
53
Emilian Peev538c90e2018-12-17 18:03:19 +000054const float CameraProviderManager::kDepthARTolerance = .1f;
55
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080056CameraProviderManager::HardwareServiceInteractionProxy
57CameraProviderManager::sHardwareServiceInteractionProxy{};
58
59CameraProviderManager::~CameraProviderManager() {
60}
61
Yin-Chia Yeh26c79972019-06-25 10:53:03 -070062hardware::hidl_vec<hardware::hidl_string>
63CameraProviderManager::HardwareServiceInteractionProxy::listServices() {
64 hardware::hidl_vec<hardware::hidl_string> ret;
65 auto manager = hardware::defaultServiceManager1_2();
66 if (manager != nullptr) {
67 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
68 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
69 ret = registered;
70 });
71 }
72 return ret;
73}
74
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080075status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
76 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080077 std::lock_guard<std::mutex> lock(mInterfaceMutex);
78 if (proxy == nullptr) {
79 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
80 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080081 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080082 mListener = listener;
83 mServiceProxy = proxy;
Eino-Ville Talvala63f36112018-12-06 14:57:03 -080084 mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
85 provider::V2_5::DeviceState::NORMAL);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080086
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080087 // Registering will trigger notifications for all already-known providers
88 bool success = mServiceProxy->registerForNotifications(
89 /* instance name, empty means no filter */ "",
90 this);
91 if (!success) {
92 ALOGE("%s: Unable to register with hardware service manager for notifications "
93 "about camera providers", __FUNCTION__);
94 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080095 }
Emilian Peev5d7e5152017-02-22 15:37:48 +000096
Yin-Chia Yeh26c79972019-06-25 10:53:03 -070097
98 for (const auto& instance : mServiceProxy->listServices()) {
99 this->addProviderLocked(instance);
100 }
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800101
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700102 IPCThreadState::self()->flushCommands();
103
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800104 return OK;
105}
106
107int CameraProviderManager::getCameraCount() const {
108 std::lock_guard<std::mutex> lock(mInterfaceMutex);
109 int count = 0;
110 for (auto& provider : mProviders) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800111 count += provider->mUniqueCameraIds.size();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800112 }
113 return count;
114}
115
116std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
117 std::lock_guard<std::mutex> lock(mInterfaceMutex);
118 std::vector<std::string> deviceIds;
119 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700120 for (auto& id : provider->mUniqueCameraIds) {
121 deviceIds.push_back(id);
122 }
123 }
124 return deviceIds;
125}
126
Emilian Peevf53f66e2017-04-11 14:29:43 +0100127std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700128 std::lock_guard<std::mutex> lock(mInterfaceMutex);
129 std::vector<std::string> deviceIds;
130 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700131 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
132
133 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700134 // for each camera facing, only take the first id advertised by HAL in
135 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700136 filterLogicalCameraIdsLocked(providerDeviceIds);
137
138 deviceIds.insert(deviceIds.end(), providerDeviceIds.begin(), providerDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800139 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800140
141 std::sort(deviceIds.begin(), deviceIds.end(),
142 [](const std::string& a, const std::string& b) -> bool {
143 uint32_t aUint = 0, bUint = 0;
144 bool aIsUint = base::ParseUint(a, &aUint);
145 bool bIsUint = base::ParseUint(b, &bUint);
146
147 // Uint device IDs first
148 if (aIsUint && bIsUint) {
149 return aUint < bUint;
150 } else if (aIsUint) {
151 return true;
152 } else if (bIsUint) {
153 return false;
154 }
155 // Simple string compare if both id are not uint
156 return a < b;
157 });
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800158 return deviceIds;
159}
160
161bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
162 std::lock_guard<std::mutex> lock(mInterfaceMutex);
163 return isValidDeviceLocked(id, majorVersion);
164}
165
166bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
167 for (auto& provider : mProviders) {
168 for (auto& deviceInfo : provider->mDevices) {
169 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
170 return true;
171 }
172 }
173 }
174 return false;
175}
176
177bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
178 std::lock_guard<std::mutex> lock(mInterfaceMutex);
179
180 auto deviceInfo = findDeviceInfoLocked(id);
181 if (deviceInfo == nullptr) return false;
182
183 return deviceInfo->hasFlashUnit();
184}
185
186status_t CameraProviderManager::getResourceCost(const std::string &id,
187 CameraResourceCost* cost) const {
188 std::lock_guard<std::mutex> lock(mInterfaceMutex);
189
190 auto deviceInfo = findDeviceInfoLocked(id);
191 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
192
193 *cost = deviceInfo->mResourceCost;
194 return OK;
195}
196
197status_t CameraProviderManager::getCameraInfo(const std::string &id,
198 hardware::CameraInfo* info) const {
199 std::lock_guard<std::mutex> lock(mInterfaceMutex);
200
201 auto deviceInfo = findDeviceInfoLocked(id);
202 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
203
204 return deviceInfo->getCameraInfo(info);
205}
206
Emilian Peev35ae8262018-11-08 13:11:32 +0000207status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
208 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
209 bool *status /*out*/) const {
210 std::lock_guard<std::mutex> lock(mInterfaceMutex);
211
212 auto deviceInfo = findDeviceInfoLocked(id);
213 if (deviceInfo == nullptr) {
214 return NAME_NOT_FOUND;
215 }
216
217 return deviceInfo->isSessionConfigurationSupported(configuration, status);
218}
219
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800220status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
221 CameraMetadata* characteristics) const {
222 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700223 return getCameraCharacteristicsLocked(id, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800224}
225
226status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
227 hardware::hidl_version *v) {
228 std::lock_guard<std::mutex> lock(mInterfaceMutex);
229
230 hardware::hidl_version maxVersion{0,0};
231 bool found = false;
232 for (auto& provider : mProviders) {
233 for (auto& deviceInfo : provider->mDevices) {
234 if (deviceInfo->mId == id) {
235 if (deviceInfo->mVersion > maxVersion) {
236 maxVersion = deviceInfo->mVersion;
237 found = true;
238 }
239 }
240 }
241 }
242 if (!found) {
243 return NAME_NOT_FOUND;
244 }
245 *v = maxVersion;
246 return OK;
247}
248
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700249bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700250 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700251 for (auto& provider : mProviders) {
252 auto deviceInfo = findDeviceInfoLocked(id);
253 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700254 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700255 }
256 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700257 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700258}
259
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800260status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
261 std::lock_guard<std::mutex> lock(mInterfaceMutex);
262
263 auto deviceInfo = findDeviceInfoLocked(id);
264 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
265
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700266 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
267 // that are currently in use.
268 const sp<provider::V2_4::ICameraProvider> interface =
269 deviceInfo->mParentProvider->startProviderInterface();
270 if (interface == nullptr) {
271 return DEAD_OBJECT;
272 }
273 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
274
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800275 return deviceInfo->setTorchMode(enabled);
276}
277
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800278status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000279 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
280
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800281 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800282 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800283 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000284
285 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
286
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800287 return OK;
288}
289
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800290status_t CameraProviderManager::notifyDeviceStateChange(
291 hardware::hidl_bitfield<provider::V2_5::DeviceState> newState) {
292 std::lock_guard<std::mutex> lock(mInterfaceMutex);
293 mDeviceState = newState;
294 status_t res = OK;
295 for (auto& provider : mProviders) {
296 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
297 __FUNCTION__, provider->mProviderName.c_str(), newState);
298 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
299 if (singleRes != OK) {
300 ALOGE("%s: Unable to notify provider %s about device state change",
301 __FUNCTION__,
302 provider->mProviderName.c_str());
303 res = singleRes;
304 // continue to do the rest of the providers instead of returning now
305 }
306 }
307 return res;
308}
309
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800310status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800311 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800312 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800313 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800314
315 std::lock_guard<std::mutex> lock(mInterfaceMutex);
316
317 auto deviceInfo = findDeviceInfoLocked(id,
318 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
319 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
320
321 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700322 const sp<provider::V2_4::ICameraProvider> provider =
323 deviceInfo->mParentProvider->startProviderInterface();
324 if (provider == nullptr) {
325 return DEAD_OBJECT;
326 }
327 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800328
329 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700330 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700331 auto interface = deviceInfo3->startDeviceInterface<
332 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
333 if (interface == nullptr) {
334 return DEAD_OBJECT;
335 }
336
337 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800338 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
339 status = s;
340 if (status == Status::OK) {
341 *session = cameraSession;
342 }
343 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700344 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700345 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700346 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
347 __FUNCTION__, id.c_str(), ret.description().c_str());
348 return DEAD_OBJECT;
349 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800350 return mapToStatusT(status);
351}
352
353status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800354 const sp<device::V1_0::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800355 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800356 sp<device::V1_0::ICameraDevice> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800357
358 std::lock_guard<std::mutex> lock(mInterfaceMutex);
359
360 auto deviceInfo = findDeviceInfoLocked(id,
361 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
362 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
363
364 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700365 const sp<provider::V2_4::ICameraProvider> provider =
366 deviceInfo->mParentProvider->startProviderInterface();
367 if (provider == nullptr) {
368 return DEAD_OBJECT;
369 }
370 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800371
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700372 auto interface = deviceInfo1->startDeviceInterface<
373 CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT>();
374 if (interface == nullptr) {
375 return DEAD_OBJECT;
376 }
377 hardware::Return<Status> status = interface->open(callback);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700378 if (!status.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700379 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700380 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
381 __FUNCTION__, id.c_str(), status.description().c_str());
382 return DEAD_OBJECT;
383 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800384 if (status == Status::OK) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700385 *session = interface;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800386 }
387 return mapToStatusT(status);
388}
389
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700390void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
391 sp<provider::V2_4::ICameraProvider> provider) {
392 if (!kEnableLazyHal) {
393 return;
394 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800395 ALOGV("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700396 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
397 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
398 if (usageType == DeviceMode::TORCH) {
399 primaryMap = &mTorchProviderByCameraId;
400 alternateMap = &mCameraProviderByCameraId;
401 } else {
402 primaryMap = &mCameraProviderByCameraId;
403 alternateMap = &mTorchProviderByCameraId;
404 }
405 auto id = cameraId.c_str();
406 (*primaryMap)[id] = provider;
407 auto search = alternateMap->find(id);
408 if (search != alternateMap->end()) {
409 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
410 "That should not be possible", __FUNCTION__, id);
411 }
412 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
413}
414
415void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
416 if (!kEnableLazyHal) {
417 return;
418 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800419 ALOGV("Removing camera device %s", cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700420 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
421 if (usageType == DeviceMode::TORCH) {
422 providerMap = &mTorchProviderByCameraId;
423 } else {
424 providerMap = &mCameraProviderByCameraId;
425 }
426 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
427 auto search = providerMap->find(cameraId.c_str());
428 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800429 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
430 // added delay) because hwservicemanager guarantees to hold the reference for at least five
431 // more seconds. We depend on this behavior so that if the provider is unreferenced and
432 // then referenced again quickly, we do not let the HAL exit and then need to immediately
433 // restart it. An example when this could happen is switching from a front-facing to a
434 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
435 // appear janky to the user.
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700436 providerMap->erase(cameraId.c_str());
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800437 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700438 } else {
439 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
440 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
441 cameraId.c_str());
442 }
443}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800444
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800445hardware::Return<void> CameraProviderManager::onRegistration(
446 const hardware::hidl_string& /*fqName*/,
447 const hardware::hidl_string& name,
448 bool /*preexisting*/) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700449 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100450 {
451 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800452
Emilian Peevaee727d2017-05-04 16:35:48 +0100453 addProviderLocked(name);
454 }
455
456 sp<StatusListener> listener = getStatusListener();
457 if (nullptr != listener.get()) {
458 listener->onNewProviderRegistered();
459 }
460
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700461 IPCThreadState::self()->flushCommands();
462
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800463 return hardware::Return<void>();
464}
465
466status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
467 std::lock_guard<std::mutex> lock(mInterfaceMutex);
468
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800469 for (auto& provider : mProviders) {
470 provider->dump(fd, args);
471 }
472 return OK;
473}
474
475CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800476 const std::string& id,
477 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800478 for (auto& provider : mProviders) {
479 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800480 if (deviceInfo->mId == id &&
481 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800482 return deviceInfo.get();
483 }
484 }
485 }
486 return nullptr;
487}
488
Emilian Peev71c73a22017-03-21 16:35:51 +0000489metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
490 const std::string& id, hardware::hidl_version minVersion,
491 hardware::hidl_version maxVersion) const {
492 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
493
494 std::lock_guard<std::mutex> lock(mInterfaceMutex);
495 for (auto& provider : mProviders) {
496 for (auto& deviceInfo : provider->mDevices) {
497 if (deviceInfo->mId == id &&
498 minVersion <= deviceInfo->mVersion &&
499 maxVersion >= deviceInfo->mVersion) {
500 return provider->mProviderTagid;
501 }
502 }
503 }
504
505 return ret;
506}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800507
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700508void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
509 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700510
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700511 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700512 for (size_t i = 0; i < entryCap.count; ++i) {
513 uint8_t capability = entryCap.data.u8[i];
514 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700515 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700516 break;
517 }
518 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700519 if (!mIsLogicalCamera) {
520 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700521 }
522
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700523 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
524 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700525 const uint8_t* ids = entryIds.data.u8;
526 size_t start = 0;
527 for (size_t i = 0; i < entryIds.count; ++i) {
528 if (ids[i] == '\0') {
529 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700530 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700531 }
532 start = i+1;
533 }
534 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700535}
536
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800537bool CameraProviderManager::ProviderInfo::DeviceInfo3::isPublicallyHiddenSecureCamera() {
538 camera_metadata_entry_t entryCap;
539 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
540 if (entryCap.count != 1) {
541 // Do NOT hide this camera device if the capabilities specify anything more
542 // than ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA.
543 return false;
544 }
545 return entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA;
546}
547
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000548void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
549 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
550 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
551 if (sizes == nullptr) {
552 return;
553 }
554
555 auto scalerDims = ch.find(tag);
556 if (scalerDims.count > 0) {
557 // Scaler entry contains 4 elements (format, width, height, type)
558 for (size_t i = 0; i < scalerDims.count; i += 4) {
559 if ((scalerDims.data.i32[i] == format) &&
560 (scalerDims.data.i32[i+3] ==
561 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
562 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
563 scalerDims.data.i32[i+2]));
564 }
565 }
566 }
567}
568
569void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
570 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
571 const std::vector<std::tuple<size_t, size_t>>& sizes,
572 std::vector<int64_t> *durations/*out*/) {
573 if (durations == nullptr) {
574 return;
575 }
576
577 auto availableDurations = ch.find(tag);
578 if (availableDurations.count > 0) {
579 // Duration entry contains 4 elements (format, width, height, duration)
580 for (size_t i = 0; i < availableDurations.count; i += 4) {
581 for (const auto& size : sizes) {
582 int64_t width = std::get<0>(size);
583 int64_t height = std::get<1>(size);
584 if ((availableDurations.data.i64[i] == format) &&
585 (availableDurations.data.i64[i+1] == width) &&
586 (availableDurations.data.i64[i+2] == height)) {
587 durations->push_back(availableDurations.data.i64[i+3]);
588 }
589 }
590 }
591 }
592}
593void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
594 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
595 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
596 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
597 return;
598 }
599
600 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
601 // Processing time on camera service side can vary greatly depending on multiple
602 // variables which are not under our control. Make a guesstimate by taking the maximum
603 // corresponding duration value from depth and blob.
604 auto depthDuration = depthDurations.begin();
605 auto blobDuration = blobDurations.begin();
606 dynamicDepthDurations->reserve(depthDurations.size());
607 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
608 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
609 depthDuration++; blobDuration++;
610 }
611}
612
613void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
614 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
615 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
616 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
617 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
618 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
619 return;
620 }
621
622 // The dynamic depth spec. does not mention how close the AR ratio should be.
623 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000624 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000625
626 for (const auto& blobSize : blobSizes) {
627 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
628 static_cast<float>(std::get<1>(blobSize));
629 bool found = false;
630 for (const auto& depthSize : depthSizes) {
631 if (depthSize == blobSize) {
632 internalDepthSizes->push_back(depthSize);
633 found = true;
634 break;
635 } else {
636 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
637 static_cast<float>(std::get<1>(depthSize));
638 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
639 internalDepthSizes->push_back(depthSize);
640 found = true;
641 break;
642 }
643 }
644 }
645
646 if (found) {
647 dynamicDepthSizes->push_back(blobSize);
648 }
649 }
650}
651
Emilian Peevcbf174b2019-01-25 14:38:59 -0800652bool CameraProviderManager::ProviderInfo::DeviceInfo3::isDepthPhotoLibraryPresent() {
653 static bool libraryPresent = false;
654 static bool initialized = false;
655 if (initialized) {
656 return libraryPresent;
657 } else {
658 initialized = true;
659 }
660
661 void* depthLibHandle = dlopen(camera3::kDepthPhotoLibrary, RTLD_NOW | RTLD_LOCAL);
662 if (depthLibHandle == nullptr) {
663 return false;
664 }
665
666 auto processFunc = dlsym(depthLibHandle, camera3::kDepthPhotoProcessFunction);
667 if (processFunc != nullptr) {
668 libraryPresent = true;
669 } else {
670 libraryPresent = false;
671 }
672 dlclose(depthLibHandle);
673
674 return libraryPresent;
675}
676
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000677status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags() {
678 uint32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
679 uint32_t depthSizesTag = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS;
680 auto& c = mCameraCharacteristics;
681 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
682 supportedDynamicDepthSizes, internalDepthSizes;
683 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
684 if (chTags.count == 0) {
685 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
686 return BAD_VALUE;
687 }
688
689 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
690 depthExclTag) != (chTags.data.i32 + chTags.count);
691 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -0800692 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000693 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
694 // No depth support, nothing more to do.
695 return OK;
696 }
697
698 auto depthExclusiveEntry = c.find(depthExclTag);
699 if (depthExclusiveEntry.count > 0) {
700 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
701 // Depth support is exclusive, nothing more to do.
702 return OK;
703 }
704 } else {
705 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
706 return BAD_VALUE;
707 }
708
709 getSupportedSizes(c, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, HAL_PIXEL_FORMAT_BLOB,
710 &supportedBlobSizes);
711 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
712 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
713 // Nothing to do in this case.
714 return OK;
715 }
716
717 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
718 &supportedDynamicDepthSizes, &internalDepthSizes);
719 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000720 // Nothing more to do.
721 return OK;
722 }
723
Emilian Peevcbf174b2019-01-25 14:38:59 -0800724 if(!isDepthPhotoLibraryPresent()) {
725 // Depth photo processing library is not present, nothing more to do.
726 return OK;
727 }
728
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000729 std::vector<int32_t> dynamicDepthEntries;
730 for (const auto& it : supportedDynamicDepthSizes) {
731 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
732 static_cast<int32_t> (std::get<1>(it)),
733 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
734 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
735 }
736
737 std::vector<int64_t> depthMinDurations, depthStallDurations;
738 std::vector<int64_t> blobMinDurations, blobStallDurations;
739 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
740
741 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,
742 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthMinDurations);
743 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
744 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobMinDurations);
745 if (blobMinDurations.empty() || depthMinDurations.empty() ||
746 (depthMinDurations.size() != blobMinDurations.size())) {
747 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
748 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
749 return BAD_VALUE;
750 }
751
752 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS,
753 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthStallDurations);
754 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
755 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobStallDurations);
756 if (blobStallDurations.empty() || depthStallDurations.empty() ||
757 (depthStallDurations.size() != blobStallDurations.size())) {
758 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
759 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
760 return BAD_VALUE;
761 }
762
763 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
764 &dynamicDepthMinDurations);
765 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
766 &dynamicDepthStallDurations);
767 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
768 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
769 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
770 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
771 return BAD_VALUE;
772 }
773
774 std::vector<int64_t> dynamicDepthMinDurationEntries;
775 auto itDuration = dynamicDepthMinDurations.begin();
776 auto itSize = supportedDynamicDepthSizes.begin();
777 while (itDuration != dynamicDepthMinDurations.end()) {
778 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
779 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
780 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
781 entry + 4);
782 itDuration++; itSize++;
783 }
784
785 std::vector<int64_t> dynamicDepthStallDurationEntries;
786 itDuration = dynamicDepthStallDurations.begin();
787 itSize = supportedDynamicDepthSizes.begin();
788 while (itDuration != dynamicDepthStallDurations.end()) {
789 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
790 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
791 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
792 entry + 4);
793 itDuration++; itSize++;
794 }
795
796 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
797 dynamicDepthEntries.data(), dynamicDepthEntries.size());
798 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,
799 dynamicDepthMinDurationEntries.data(), dynamicDepthMinDurationEntries.size());
800 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,
801 dynamicDepthStallDurationEntries.data(), dynamicDepthStallDurationEntries.size());
802
803 std::vector<int32_t> supportedChTags;
804 supportedChTags.reserve(chTags.count + 3);
805 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
806 chTags.data.i32 + chTags.count);
807 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
808 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS);
809 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS);
810 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
811 supportedChTags.size());
812
813 return OK;
814}
815
Shuzhen Wang268a1362018-10-16 16:32:59 -0700816status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
817 status_t res = OK;
818 auto& c = mCameraCharacteristics;
819
820 // Override static metadata for MONOCHROME camera with older device version
821 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
822 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
823 for (size_t i = 0; i < cap.count; i++) {
824 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
825 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
826 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
827 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
828 if (res != OK) {
829 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
830 __FUNCTION__, strerror(-res), res);
831 return res;
832 }
833
834 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
835 const std::vector<uint32_t> sKeys = {
836 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
837 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
838 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
839 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
840 ANDROID_SENSOR_COLOR_TRANSFORM1,
841 ANDROID_SENSOR_COLOR_TRANSFORM2,
842 ANDROID_SENSOR_FORWARD_MATRIX1,
843 ANDROID_SENSOR_FORWARD_MATRIX2,
844 };
845 res = removeAvailableKeys(c, sKeys,
846 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
847 if (res != OK) {
848 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
849 __FUNCTION__, strerror(-res), res);
850 return res;
851 }
852
853 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
854 const std::vector<uint32_t> reqKeys = {
855 ANDROID_COLOR_CORRECTION_MODE,
856 ANDROID_COLOR_CORRECTION_TRANSFORM,
857 ANDROID_COLOR_CORRECTION_GAINS,
858 };
859 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
860 if (res != OK) {
861 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
862 __FUNCTION__, strerror(-res), res);
863 return res;
864 }
865
866 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
867 const std::vector<uint32_t> resKeys = {
868 ANDROID_SENSOR_GREEN_SPLIT,
869 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
870 ANDROID_COLOR_CORRECTION_MODE,
871 ANDROID_COLOR_CORRECTION_TRANSFORM,
872 ANDROID_COLOR_CORRECTION_GAINS,
873 };
874 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
875 if (res != OK) {
876 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
877 __FUNCTION__, strerror(-res), res);
878 return res;
879 }
880
881 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
882 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
883 for (size_t j = 1; j < blEntry.count; j++) {
884 blEntry.data.i32[j] = blEntry.data.i32[0];
885 }
886 }
887 }
888 }
889 return res;
890}
891
892status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
893 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
894 status_t res = OK;
895
896 camera_metadata_entry keysEntry = c.find(keyTag);
897 if (keysEntry.count == 0) {
898 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
899 return res;
900 }
901 std::vector<int32_t> vKeys;
902 vKeys.reserve(keysEntry.count);
903 for (size_t i = 0; i < keysEntry.count; i++) {
904 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
905 vKeys.push_back(keysEntry.data.i32[i]);
906 }
907 }
908 res = c.update(keyTag, vKeys.data(), vKeys.size());
909 return res;
910}
911
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -0800912status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
913 std::vector<int32_t>* outputs,
914 std::vector<int64_t>* durations,
915 std::vector<int64_t>* stallDurations,
916 const camera_metadata_entry& halStreamConfigs,
917 const camera_metadata_entry& halStreamDurations) {
918 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
919 return BAD_VALUE;
920 }
921
922 static bool supportInMemoryTempFile =
923 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
924 if (!supportInMemoryTempFile) {
925 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
926 __FUNCTION__);
927 return OK;
928 }
929
930 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
931 int32_t format = halStreamConfigs.data.i32[i];
932 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
933 // image.
934 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
935 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
936 continue;
937 }
938
939 bool sizeAvail = false;
940 for (size_t j = 0; j < outputs->size(); j+= 4) {
941 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
942 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
943 sizeAvail = true;
944 break;
945 }
946 }
947 if (sizeAvail) continue;
948
949 int64_t stall = 0;
950 bool useHeic, useGrid;
951 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
952 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
953 &useHeic, &useGrid, &stall)) {
954 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
955 continue;
956 }
957
958 // HEIC configuration
959 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
960 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
961 outputs->insert(outputs->end(), config, config + 4);
962
963 // HEIC minFrameDuration
964 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
965 if (halStreamDurations.data.i64[j] == format &&
966 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
967 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
968 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
969 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
970 durations->insert(durations->end(), duration, duration+4);
971 break;
972 }
973 }
974
975 // HEIC stallDuration
976 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
977 halStreamConfigs.data.i32[i+2], stall};
978 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
979 }
980 }
981 return OK;
982}
983
984status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags() {
985 auto& c = mCameraCharacteristics;
986
987 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
988 if (halHeicSupport.count > 1) {
989 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
990 __FUNCTION__, halHeicSupport.count);
991 return BAD_VALUE;
992 } else if (halHeicSupport.count == 0 ||
993 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
994 // Camera HAL doesn't support mandatory stream combinations for HEIC.
995 return OK;
996 }
997
998 camera_metadata_entry maxJpegAppsSegments =
999 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1000 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1001 maxJpegAppsSegments.data.u8[0] > 16) {
1002 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1003 __FUNCTION__);
1004 return BAD_VALUE;
1005 }
1006
1007 // Populate HEIC output configurations and its related min frame duration
1008 // and stall duration.
1009 std::vector<int32_t> heicOutputs;
1010 std::vector<int64_t> heicDurations;
1011 std::vector<int64_t> heicStallDurations;
1012
1013 camera_metadata_entry halStreamConfigs =
1014 c.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
1015 camera_metadata_entry minFrameDurations =
1016 c.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
1017
1018 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
1019 halStreamConfigs, minFrameDurations);
1020 if (res != OK) {
1021 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
1022 strerror(-res), res);
1023 return res;
1024 }
1025
1026 c.update(ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS,
1027 heicOutputs.data(), heicOutputs.size());
1028 c.update(ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS,
1029 heicDurations.data(), heicDurations.size());
1030 c.update(ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS,
1031 heicStallDurations.data(), heicStallDurations.size());
1032
1033 return OK;
1034}
1035
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001036bool CameraProviderManager::isLogicalCamera(const std::string& id,
1037 std::vector<std::string>* physicalCameraIds) {
1038 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1039
1040 auto deviceInfo = findDeviceInfoLocked(id);
1041 if (deviceInfo == nullptr) return false;
1042
1043 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
1044 *physicalCameraIds = deviceInfo->mPhysicalIds;
1045 }
1046 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001047}
1048
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001049bool CameraProviderManager::isPublicallyHiddenSecureCamera(const std::string& id) {
1050 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1051
1052 auto deviceInfo = findDeviceInfoLocked(id);
1053 if (deviceInfo == nullptr) {
1054 return false;
1055 }
1056 return deviceInfo->mIsPublicallyHiddenSecureCamera;
1057}
1058
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001059bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) {
1060 for (auto& provider : mProviders) {
1061 for (auto& deviceInfo : provider->mDevices) {
1062 if (deviceInfo->mId == cameraId) {
1063 // cameraId is found in public camera IDs advertised by the
1064 // provider.
1065 return false;
1066 }
1067 }
1068 }
1069
1070 for (auto& provider : mProviders) {
1071 for (auto& deviceInfo : provider->mDevices) {
1072 CameraMetadata info;
1073 status_t res = deviceInfo->getCameraCharacteristics(&info);
1074 if (res != OK) {
1075 ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
1076 deviceInfo->mId.c_str());
1077 return false;
1078 }
1079
1080 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001081 if (deviceInfo->mIsLogicalCamera) {
1082 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1083 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001084 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
1085 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
1086 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
1087 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
1088 __FUNCTION__, deviceVersion, cameraId.c_str());
1089 return false;
1090 } else {
1091 return true;
1092 }
1093 }
1094 }
1095 }
1096 }
1097
1098 return false;
1099}
1100
Yin-Chia Yeh26c79972019-06-25 10:53:03 -07001101status_t CameraProviderManager::addProviderLocked(const std::string& newProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001102 for (const auto& providerInfo : mProviders) {
1103 if (providerInfo->mProviderName == newProvider) {
1104 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
1105 newProvider.c_str());
1106 return ALREADY_EXISTS;
1107 }
1108 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001109
1110 sp<provider::V2_4::ICameraProvider> interface;
1111 interface = mServiceProxy->getService(newProvider);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001112
1113 if (interface == nullptr) {
Yin-Chia Yeh26c79972019-06-25 10:53:03 -07001114 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
1115 newProvider.c_str());
1116 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001117 }
1118
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001119 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001120 status_t res = providerInfo->initialize(interface, mDeviceState);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001121 if (res != OK) {
1122 return res;
1123 }
1124
1125 mProviders.push_back(providerInfo);
1126
1127 return OK;
1128}
1129
1130status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07001131 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001132 std::unique_lock<std::mutex> lock(mInterfaceMutex);
1133 std::vector<String8> removedDeviceIds;
1134 status_t res = NAME_NOT_FOUND;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001135 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
1136 if ((*it)->mProviderName == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001137 removedDeviceIds.reserve((*it)->mDevices.size());
1138 for (auto& deviceInfo : (*it)->mDevices) {
1139 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
1140 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001141 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001142 res = OK;
1143 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001144 }
1145 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001146 if (res != OK) {
1147 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1148 provider.c_str());
1149 } else {
1150 // Inform camera service of loss of presence for all the devices from this provider,
1151 // without lock held for reentrancy
1152 sp<StatusListener> listener = getStatusListener();
1153 if (listener != nullptr) {
1154 lock.unlock();
1155 for (auto& id : removedDeviceIds) {
1156 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1157 }
1158 }
1159 }
1160 return res;
1161}
1162
1163sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1164 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001165}
1166
1167/**** Methods for ProviderInfo ****/
1168
1169
1170CameraProviderManager::ProviderInfo::ProviderInfo(
1171 const std::string &providerName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001172 CameraProviderManager *manager) :
1173 mProviderName(providerName),
Emilian Peev71c73a22017-03-21 16:35:51 +00001174 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001175 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001176 mManager(manager) {
1177 (void) mManager;
1178}
1179
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001180status_t CameraProviderManager::ProviderInfo::initialize(
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001181 sp<provider::V2_4::ICameraProvider>& interface,
1182 hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001183 status_t res = parseProviderName(mProviderName, &mType, &mId);
1184 if (res != OK) {
1185 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1186 return BAD_VALUE;
1187 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001188 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001189 mProviderName.c_str(), interface->isRemote());
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001190
1191 // Determine minor version
1192 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1193 if (castResult.isOk()) {
1194 mMinorVersion = 5;
1195 } else {
1196 mMinorVersion = 4;
1197 }
1198
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001199 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1200 // before setCallback returns
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001201 hardware::Return<Status> status = interface->setCallback(this);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001202 if (!status.isOk()) {
1203 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1204 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1205 return DEAD_OBJECT;
1206 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001207 if (status != Status::OK) {
1208 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1209 __FUNCTION__, mProviderName.c_str());
1210 return mapToStatusT(status);
1211 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001212
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001213 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001214 if (!linked.isOk()) {
1215 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1216 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1217 return DEAD_OBJECT;
1218 } else if (!linked) {
1219 ALOGW("%s: Unable to link to provider '%s' death notifications",
1220 __FUNCTION__, mProviderName.c_str());
1221 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001222
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001223 if (!kEnableLazyHal) {
1224 // Save HAL reference indefinitely
1225 mSavedInterface = interface;
1226 } else {
1227 mActiveInterface = interface;
1228 }
1229
1230 ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
1231 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1232 notifyDeviceStateChange(currentDeviceState);
1233
1234 res = setUpVendorTags();
1235 if (res != OK) {
1236 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1237 __FUNCTION__, mProviderName.c_str());
1238 return res;
1239 }
1240
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001241 // Get initial list of camera devices, if any
1242 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001243 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001244 Status idStatus,
1245 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1246 status = idStatus;
1247 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001248 for (auto& name : cameraDeviceNames) {
1249 uint16_t major, minor;
1250 std::string type, id;
1251 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1252 if (res != OK) {
1253 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1254 status = Status::INTERNAL_ERROR;
1255 } else {
1256 devices.push_back(name);
1257 mProviderPublicCameraIds.push_back(id);
1258 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001259 }
1260 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001261 if (!ret.isOk()) {
1262 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1263 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1264 return DEAD_OBJECT;
1265 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001266 if (status != Status::OK) {
1267 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1268 __FUNCTION__, mProviderName.c_str());
1269 return mapToStatusT(status);
1270 }
1271
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001272 ret = interface->isSetTorchModeSupported(
1273 [this](auto status, bool supported) {
1274 if (status == Status::OK) {
1275 mSetTorchModeSupported = supported;
1276 }
1277 });
1278 if (!ret.isOk()) {
1279 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1280 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1281 return DEAD_OBJECT;
1282 }
1283
1284 mIsRemote = interface->isRemote();
1285
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001286 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001287 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001288 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001289 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001290 if (res != OK) {
1291 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1292 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001293 continue;
1294 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001295 }
1296
1297 ALOGI("Camera provider %s ready with %zu camera devices",
1298 mProviderName.c_str(), mDevices.size());
1299
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001300 mInitialized = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001301 return OK;
1302}
1303
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001304const sp<provider::V2_4::ICameraProvider>
1305CameraProviderManager::ProviderInfo::startProviderInterface() {
1306 ATRACE_CALL();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001307 ALOGV("Request to start camera provider: %s", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001308 if (mSavedInterface != nullptr) {
1309 return mSavedInterface;
1310 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001311 if (!kEnableLazyHal) {
1312 ALOGE("Bad provider state! Should not be here on a non-lazy HAL!");
1313 return nullptr;
1314 }
1315
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001316 auto interface = mActiveInterface.promote();
1317 if (interface == nullptr) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001318 ALOGI("Camera HAL provider needs restart, calling getService(%s)", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001319 interface = mManager->mServiceProxy->getService(mProviderName);
1320 interface->setCallback(this);
1321 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
1322 if (!linked.isOk()) {
1323 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1324 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1325 mManager->removeProvider(mProviderName);
1326 return nullptr;
1327 } else if (!linked) {
1328 ALOGW("%s: Unable to link to provider '%s' death notifications",
1329 __FUNCTION__, mProviderName.c_str());
1330 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001331 // Send current device state
1332 if (mMinorVersion >= 5) {
1333 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1334 if (castResult.isOk()) {
1335 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1336 if (interface_2_5 != nullptr) {
1337 ALOGV("%s: Initial device state for %s: 0x %" PRIx64,
1338 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1339 interface_2_5->notifyDeviceStateChange(mDeviceState);
1340 }
1341 }
1342 }
1343
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001344 mActiveInterface = interface;
1345 } else {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001346 ALOGV("Camera provider (%s) already in use. Re-using instance.", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001347 }
1348 return interface;
1349}
1350
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001351const std::string& CameraProviderManager::ProviderInfo::getType() const {
1352 return mType;
1353}
1354
1355status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1356 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1357
1358 ALOGI("Enumerating new camera device: %s", name.c_str());
1359
1360 uint16_t major, minor;
1361 std::string type, id;
1362
1363 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1364 if (res != OK) {
1365 return res;
1366 }
1367 if (type != mType) {
1368 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1369 type.c_str(), mType.c_str());
1370 return BAD_VALUE;
1371 }
1372 if (mManager->isValidDeviceLocked(id, major)) {
1373 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1374 name.c_str(), id.c_str(), major);
1375 return BAD_VALUE;
1376 }
1377
1378 std::unique_ptr<DeviceInfo> deviceInfo;
1379 switch (major) {
1380 case 1:
Emilian Peev71c73a22017-03-21 16:35:51 +00001381 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
1382 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001383 break;
1384 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001385 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1386 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001387 break;
1388 default:
1389 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1390 name.c_str(), major);
1391 return BAD_VALUE;
1392 }
1393 if (deviceInfo == nullptr) return BAD_VALUE;
1394 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001395 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001396
1397 mDevices.push_back(std::move(deviceInfo));
1398
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001399 mUniqueCameraIds.insert(id);
1400 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001401 // addDevice can be called more than once for the same camera id if HAL
1402 // supports openLegacy.
1403 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1404 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1405 mUniqueAPI1CompatibleCameraIds.push_back(id);
1406 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001407 }
1408
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001409 if (parsedId != nullptr) {
1410 *parsedId = id;
1411 }
1412 return OK;
1413}
1414
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001415void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1416 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1417 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001418 mUniqueCameraIds.erase(id);
1419 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001420 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
1421 mUniqueAPI1CompatibleCameraIds.begin(),
1422 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001423 }
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001424 mDevices.erase(it);
1425 break;
1426 }
1427 }
1428}
1429
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001430status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001431 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
1432 mProviderName.c_str(),
1433 mMinorVersion,
1434 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001435 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001436
1437 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001438 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1439 device->mVersion.get_major(), device->mVersion.get_minor());
1440 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1441 if (device->mResourceCost.conflictingDevices.size() == 0) {
1442 dprintf(fd, " Conflicting devices: None\n");
1443 } else {
1444 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001445 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001446 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001447 device->mResourceCost.conflictingDevices[i].c_str());
1448 }
1449 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001450 dprintf(fd, " API1 info:\n");
1451 dprintf(fd, " Has a flash unit: %s\n",
1452 device->hasFlashUnit() ? "true" : "false");
1453 hardware::CameraInfo info;
1454 status_t res = device->getCameraInfo(&info);
1455 if (res != OK) {
1456 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1457 strerror(-res), res);
1458 } else {
1459 dprintf(fd, " Facing: %s\n",
1460 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1461 dprintf(fd, " Orientation: %d\n", info.orientation);
1462 }
1463 CameraMetadata info2;
1464 res = device->getCameraCharacteristics(&info2);
1465 if (res == INVALID_OPERATION) {
1466 dprintf(fd, " API2 not directly supported\n");
1467 } else if (res != OK) {
1468 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1469 strerror(-res), res);
1470 } else {
1471 dprintf(fd, " API2 camera characteristics:\n");
1472 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1473 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001474
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001475 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001476 if (device->mIsLogicalCamera) {
1477 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001478 // Skip if physical id is an independent camera
1479 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1480 != mProviderPublicCameraIds.end()) {
1481 continue;
1482 }
1483
1484 CameraMetadata physicalInfo;
1485 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1486 if (status == OK) {
1487 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1488 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1489 }
1490 }
1491 }
1492
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001493 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1494 device->mVersion.get_major(), device->mVersion.get_minor());
1495 res = device->dumpState(fd);
1496 if (res != OK) {
1497 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1498 device->mName.c_str(), strerror(-res), res);
1499 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001500 }
1501 return OK;
1502}
1503
1504hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1505 const hardware::hidl_string& cameraDeviceName,
1506 CameraDeviceStatus newStatus) {
1507 sp<StatusListener> listener;
1508 std::string id;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001509 bool initialized = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001510 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001511 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001512 bool known = false;
1513 for (auto& deviceInfo : mDevices) {
1514 if (deviceInfo->mName == cameraDeviceName) {
1515 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
1516 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
1517 deviceInfo->mStatus = newStatus;
1518 // TODO: Handle device removal (NOT_PRESENT)
1519 id = deviceInfo->mId;
1520 known = true;
1521 break;
1522 }
1523 }
1524 // Previously unseen device; status must not be NOT_PRESENT
1525 if (!known) {
1526 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1527 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
1528 mProviderName.c_str(), cameraDeviceName.c_str());
1529 return hardware::Void();
1530 }
1531 addDevice(cameraDeviceName, newStatus, &id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001532 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1533 removeDevice(id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001534 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001535 listener = mManager->getStatusListener();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001536 initialized = mInitialized;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001537 }
1538 // Call without lock held to allow reentrancy into provider manager
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001539 // Don't send the callback if providerInfo hasn't been initialized.
1540 // CameraService will initialize device status after provider is
1541 // initialized
1542 if (listener != nullptr && initialized) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001543 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
1544 }
1545 return hardware::Void();
1546}
1547
1548hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
1549 const hardware::hidl_string& cameraDeviceName,
1550 TorchModeStatus newStatus) {
1551 sp<StatusListener> listener;
1552 std::string id;
1553 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001554 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001555 bool known = false;
1556 for (auto& deviceInfo : mDevices) {
1557 if (deviceInfo->mName == cameraDeviceName) {
1558 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
1559 torchStatusToString(newStatus));
1560 id = deviceInfo->mId;
1561 known = true;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001562 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
1563 mManager->removeRef(DeviceMode::TORCH, id);
1564 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001565 break;
1566 }
1567 }
1568 if (!known) {
1569 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
1570 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
1571 return hardware::Void();
1572 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001573 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001574 }
1575 // Call without lock held to allow reentrancy into provider manager
1576 if (listener != nullptr) {
1577 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
1578 }
1579 return hardware::Void();
1580}
1581
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001582void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
1583 const wp<hidl::base::V1_0::IBase>& who) {
1584 (void) who;
1585 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
1586 if (cookie != mId) {
1587 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
1588 __FUNCTION__, cookie, mId);
1589 }
1590 mManager->removeProvider(mProviderName);
1591}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001592
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001593status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
1594 if (mVendorTagDescriptor != nullptr)
1595 return OK;
1596
1597 hardware::hidl_vec<VendorTagSection> vts;
1598 Status status;
1599 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001600 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1601 if (interface == nullptr) {
1602 return DEAD_OBJECT;
1603 }
1604 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001605 [&](auto s, const auto& vendorTagSecs) {
1606 status = s;
1607 if (s == Status::OK) {
1608 vts = vendorTagSecs;
1609 }
1610 });
1611 if (!ret.isOk()) {
1612 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
1613 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1614 return DEAD_OBJECT;
1615 }
1616 if (status != Status::OK) {
1617 return mapToStatusT(status);
1618 }
1619
1620 // Read all vendor tag definitions into a descriptor
1621 status_t res;
1622 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
1623 != OK) {
1624 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
1625 "received error %s (%d). Camera clients will not be able to use"
1626 "vendor tags", __FUNCTION__, strerror(res), res);
1627 return res;
1628 }
1629
1630 return OK;
1631}
1632
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001633status_t CameraProviderManager::ProviderInfo::notifyDeviceStateChange(
1634 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
1635 mDeviceState = newDeviceState;
1636 if (mMinorVersion >= 5) {
1637 // Check if the provider is currently active - not going to start it up for this notification
1638 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
1639 if (interface != nullptr) {
1640 // Send current device state
1641 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1642 if (castResult.isOk()) {
1643 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1644 if (interface_2_5 != nullptr) {
1645 interface_2_5->notifyDeviceStateChange(mDeviceState);
1646 }
1647 }
1648 }
1649 }
1650 return OK;
1651}
1652
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001653template<class DeviceInfoT>
1654std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
1655 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00001656 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001657 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001658 Status status;
1659
1660 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001661 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001662 if (cameraInterface == nullptr) return nullptr;
1663
1664 CameraResourceCost resourceCost;
1665 cameraInterface->getResourceCost([&status, &resourceCost](
1666 Status s, CameraResourceCost cost) {
1667 status = s;
1668 resourceCost = cost;
1669 });
1670 if (status != Status::OK) {
1671 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
1672 name.c_str(), statusToString(status));
1673 return nullptr;
1674 }
Shuzhen Wang47283692018-04-24 18:05:02 -07001675
1676 for (auto& conflictName : resourceCost.conflictingDevices) {
1677 uint16_t major, minor;
1678 std::string type, id;
1679 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
1680 if (res != OK) {
1681 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
1682 return nullptr;
1683 }
1684 conflictName = id;
1685 }
1686
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001687 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001688 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001689 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001690}
1691
1692template<class InterfaceT>
1693sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001694CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001695 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1696 name.c_str(), InterfaceT::version.get_major());
1697 return nullptr;
1698}
1699
1700template<>
1701sp<device::V1_0::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001702CameraProviderManager::ProviderInfo::startDeviceInterface
1703 <device::V1_0::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001704 Status status;
1705 sp<device::V1_0::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001706 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001707 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1708 if (interface == nullptr) {
1709 return nullptr;
1710 }
1711 ret = interface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001712 Status s, sp<device::V1_0::ICameraDevice> interface) {
1713 status = s;
1714 cameraInterface = interface;
1715 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001716 if (!ret.isOk()) {
1717 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1718 __FUNCTION__, name.c_str(), ret.description().c_str());
1719 return nullptr;
1720 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001721 if (status != Status::OK) {
1722 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1723 name.c_str(), statusToString(status));
1724 return nullptr;
1725 }
1726 return cameraInterface;
1727}
1728
1729template<>
1730sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001731CameraProviderManager::ProviderInfo::startDeviceInterface
1732 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001733 Status status;
1734 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001735 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001736 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1737 if (interface == nullptr) {
1738 return nullptr;
1739 }
1740 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001741 Status s, sp<device::V3_2::ICameraDevice> interface) {
1742 status = s;
1743 cameraInterface = interface;
1744 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001745 if (!ret.isOk()) {
1746 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1747 __FUNCTION__, name.c_str(), ret.description().c_str());
1748 return nullptr;
1749 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001750 if (status != Status::OK) {
1751 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1752 name.c_str(), statusToString(status));
1753 return nullptr;
1754 }
1755 return cameraInterface;
1756}
1757
1758CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
1759
1760template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001761sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
1762 sp<InterfaceT> device;
1763 ATRACE_CALL();
1764 if (mSavedInterface == nullptr) {
1765 device = mParentProvider->startDeviceInterface<InterfaceT>(mName);
1766 } else {
1767 device = (InterfaceT *) mSavedInterface.get();
1768 }
1769 return device;
1770}
1771
1772template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001773status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
1774 bool enabled) {
1775 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
1776 return mapToStatusT(s);
1777}
1778
1779CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001780 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001781 uint16_t minorVersion,
1782 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001783 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001784 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001785 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001786 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001787 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001788 // Get default parameters and initialize flash unit availability
1789 // Requires powering on the camera device
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001790 hardware::Return<Status> status = interface->open(nullptr);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001791 if (!status.isOk()) {
1792 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001793 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001794 return;
1795 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001796 if (status != Status::OK) {
1797 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001798 id.c_str(), CameraProviderManager::statusToString(status));
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001799 return;
1800 }
1801 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001802 ret = interface->getParameters([this](const hardware::hidl_string& parms) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001803 mDefaultParameters.unflatten(String8(parms.c_str()));
1804 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001805 if (!ret.isOk()) {
1806 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001807 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001808 return;
1809 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001810 const char *flashMode =
1811 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1812 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
1813 mHasFlashUnit = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001814 }
1815
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001816 status_t res = cacheCameraInfo(interface);
1817 if (res != OK) {
1818 ALOGE("%s: Could not cache CameraInfo", __FUNCTION__);
1819 return;
1820 }
1821
1822 ret = interface->close();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001823 if (!ret.isOk()) {
1824 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001825 __FUNCTION__, id.c_str(), status.description().c_str());
1826 }
1827
1828 if (!kEnableLazyHal) {
1829 // Save HAL reference indefinitely
1830 mSavedInterface = interface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001831 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001832}
1833
1834CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
1835
1836status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001837 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001838}
1839
1840status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
1841 hardware::CameraInfo *info) const {
1842 if (info == nullptr) return BAD_VALUE;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001843 *info = mInfo;
1844 return OK;
1845}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001846
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001847status_t CameraProviderManager::ProviderInfo::DeviceInfo1::cacheCameraInfo(
1848 sp<CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT> interface) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001849 Status status;
1850 device::V1_0::CameraInfo cInfo;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001851 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001852 ret = interface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001853 status = s;
1854 cInfo = camInfo;
1855 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001856 if (!ret.isOk()) {
1857 ALOGE("%s: Transaction error reading camera info from device %s: %s",
1858 __FUNCTION__, mId.c_str(), ret.description().c_str());
1859 return DEAD_OBJECT;
1860 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001861 if (status != Status::OK) {
1862 return mapToStatusT(status);
1863 }
1864
1865 switch(cInfo.facing) {
1866 case device::V1_0::CameraFacing::BACK:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001867 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001868 break;
1869 case device::V1_0::CameraFacing::EXTERNAL:
1870 // Map external to front for legacy API
1871 case device::V1_0::CameraFacing::FRONT:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001872 mInfo.facing = hardware::CAMERA_FACING_FRONT;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001873 break;
1874 default:
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001875 ALOGW("%s: Device %s: Unknown camera facing: %d",
1876 __FUNCTION__, mId.c_str(), cInfo.facing);
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001877 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001878 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001879 mInfo.orientation = cInfo.orientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001880
1881 return OK;
1882}
1883
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001884status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001885 native_handle_t* handle = native_handle_create(1,0);
1886 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001887 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1888 if (interface == nullptr) {
1889 return DEAD_OBJECT;
1890 }
1891 hardware::Return<Status> s = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001892 native_handle_delete(handle);
1893 if (!s.isOk()) {
1894 return INVALID_OPERATION;
1895 }
1896 return mapToStatusT(s);
1897}
1898
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001899CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001900 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001901 uint16_t minorVersion,
1902 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001903 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001904 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001905 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001906 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001907 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001908 // Get camera characteristics and initialize flash unit availability
1909 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001910 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001911 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001912 device::V3_2::CameraMetadata metadata) {
1913 status = s;
1914 if (s == Status::OK) {
1915 camera_metadata_t *buffer =
1916 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07001917 size_t expectedSize = metadata.size();
1918 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1919 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1920 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1921 mCameraCharacteristics = buffer;
1922 } else {
1923 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1924 status = Status::INTERNAL_ERROR;
1925 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001926 }
1927 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001928 if (!ret.isOk()) {
1929 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001930 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001931 ret.description().c_str());
1932 return;
1933 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001934 if (status != Status::OK) {
1935 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001936 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001937 return;
1938 }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001939
1940 mIsPublicallyHiddenSecureCamera = isPublicallyHiddenSecureCamera();
1941
Shuzhen Wang268a1362018-10-16 16:32:59 -07001942 status_t res = fixupMonochromeTags();
1943 if (OK != res) {
1944 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
1945 __FUNCTION__, strerror(-res), res);
1946 return;
1947 }
Emilian Peeva1185162019-01-30 16:41:43 -08001948 auto stat = addDynamicDepthTags();
1949 if (OK != stat) {
1950 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-stat),
1951 stat);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001952 }
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001953 res = deriveHeicTags();
1954 if (OK != res) {
1955 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities: %s (%d)",
1956 __FUNCTION__, strerror(-res), res);
1957 }
1958
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001959 camera_metadata_entry flashAvailable =
1960 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
1961 if (flashAvailable.count == 1 &&
1962 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
1963 mHasFlashUnit = true;
1964 } else {
1965 mHasFlashUnit = false;
1966 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001967
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001968 queryPhysicalCameraIds();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001969
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001970 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001971 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001972 if (!castResult.isOk()) {
1973 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
1974 return;
1975 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001976 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001977 if (interface_3_5 == nullptr) {
1978 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
1979 return;
1980 }
1981
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001982 if (mIsLogicalCamera) {
1983 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001984 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
1985 mPublicCameraIds.end()) {
1986 continue;
1987 }
1988
1989 hardware::hidl_string hidlId(id);
1990 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
1991 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
1992 status = s;
1993 if (s == Status::OK) {
1994 camera_metadata_t *buffer =
1995 reinterpret_cast<camera_metadata_t*>(metadata.data());
1996 size_t expectedSize = metadata.size();
1997 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1998 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1999 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2000 mPhysicalCameraCharacteristics[id] = buffer;
2001 } else {
2002 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2003 status = Status::INTERNAL_ERROR;
2004 }
2005 }
2006 });
2007
2008 if (!ret.isOk()) {
2009 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002010 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002011 return;
2012 }
2013 if (status != Status::OK) {
2014 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
2015 __FUNCTION__, id.c_str(), mId.c_str(),
2016 CameraProviderManager::statusToString(status), status);
2017 return;
2018 }
2019 }
2020 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002021
2022 if (!kEnableLazyHal) {
2023 // Save HAL reference indefinitely
2024 mSavedInterface = interface;
2025 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002026}
2027
2028CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
2029
2030status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002031 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002032}
2033
2034status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
2035 hardware::CameraInfo *info) const {
2036 if (info == nullptr) return BAD_VALUE;
2037
2038 camera_metadata_ro_entry facing =
2039 mCameraCharacteristics.find(ANDROID_LENS_FACING);
2040 if (facing.count == 1) {
2041 switch (facing.data.u8[0]) {
2042 case ANDROID_LENS_FACING_BACK:
2043 info->facing = hardware::CAMERA_FACING_BACK;
2044 break;
2045 case ANDROID_LENS_FACING_EXTERNAL:
2046 // Map external to front for legacy API
2047 case ANDROID_LENS_FACING_FRONT:
2048 info->facing = hardware::CAMERA_FACING_FRONT;
2049 break;
2050 }
2051 } else {
2052 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
2053 return NAME_NOT_FOUND;
2054 }
2055
2056 camera_metadata_ro_entry orientation =
2057 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
2058 if (orientation.count == 1) {
2059 info->orientation = orientation.data.i32[0];
2060 } else {
2061 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
2062 return NAME_NOT_FOUND;
2063 }
2064
2065 return OK;
2066}
Emilian Peevf53f66e2017-04-11 14:29:43 +01002067bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07002068 // Do not advertise NIR cameras to API1 camera app.
2069 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
2070 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
2071 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
2072 return false;
2073 }
2074
Emilian Peevf53f66e2017-04-11 14:29:43 +01002075 bool isBackwardCompatible = false;
2076 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
2077 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
2078 for (size_t i = 0; i < caps.count; i++) {
2079 if (caps.data.u8[i] ==
2080 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2081 isBackwardCompatible = true;
2082 break;
2083 }
2084 }
2085
2086 return isBackwardCompatible;
2087}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002088
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002089status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002090 native_handle_t* handle = native_handle_create(1,0);
2091 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002092 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
2093 if (interface == nullptr) {
2094 return DEAD_OBJECT;
2095 }
2096 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002097 native_handle_delete(handle);
2098 if (!ret.isOk()) {
2099 return INVALID_OPERATION;
2100 }
2101 return OK;
2102}
2103
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002104status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
2105 CameraMetadata *characteristics) const {
2106 if (characteristics == nullptr) return BAD_VALUE;
2107
2108 *characteristics = mCameraCharacteristics;
2109 return OK;
2110}
2111
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002112status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
2113 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
2114 if (characteristics == nullptr) return BAD_VALUE;
2115 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
2116 mPhysicalCameraCharacteristics.end()) {
2117 return NAME_NOT_FOUND;
2118 }
2119
2120 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
2121 return OK;
2122}
2123
Emilian Peev35ae8262018-11-08 13:11:32 +00002124status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
2125 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002126 bool *status /*out*/) {
2127
2128 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2129 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2130 if (interface == nullptr) {
2131 return DEAD_OBJECT;
2132 }
2133 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Emilian Peev35ae8262018-11-08 13:11:32 +00002134 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
2135 if (interface_3_5 == nullptr) {
2136 return INVALID_OPERATION;
2137 }
2138
2139 status_t res;
2140 Status callStatus;
2141 auto ret = interface_3_5->isStreamCombinationSupported(configuration,
2142 [&callStatus, &status] (Status s, bool combStatus) {
2143 callStatus = s;
2144 *status = combStatus;
2145 });
2146 if (ret.isOk()) {
2147 switch (callStatus) {
2148 case Status::OK:
2149 // Expected case, do nothing.
2150 res = OK;
2151 break;
2152 case Status::METHOD_NOT_SUPPORTED:
2153 res = INVALID_OPERATION;
2154 break;
2155 default:
2156 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
2157 res = UNKNOWN_ERROR;
2158 }
2159 } else {
2160 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2161 res = UNKNOWN_ERROR;
2162 }
2163
2164 return res;
2165}
2166
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002167status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
2168 std::string *type, uint32_t *id) {
2169 // Format must be "<type>/<id>"
2170#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
2171 "Should match '<type>/<id>' - "
2172
2173 if (!type || !id) return INVALID_OPERATION;
2174
2175 std::string::size_type slashIdx = name.find('/');
2176 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
2177 ALOGE(ERROR_MSG_PREFIX
2178 "does not have / separator between type and id",
2179 __FUNCTION__, name.c_str());
2180 return BAD_VALUE;
2181 }
2182
2183 std::string typeVal = name.substr(0, slashIdx);
2184
2185 char *endPtr;
2186 errno = 0;
2187 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
2188 if (errno != 0) {
2189 ALOGE(ERROR_MSG_PREFIX
2190 "cannot parse provider id as an integer: %s (%d)",
2191 __FUNCTION__, name.c_str(), strerror(errno), errno);
2192 return BAD_VALUE;
2193 }
2194 if (endPtr != name.c_str() + name.size()) {
2195 ALOGE(ERROR_MSG_PREFIX
2196 "provider id has unexpected length",
2197 __FUNCTION__, name.c_str());
2198 return BAD_VALUE;
2199 }
2200 if (idVal < 0) {
2201 ALOGE(ERROR_MSG_PREFIX
2202 "id is negative: %ld",
2203 __FUNCTION__, name.c_str(), idVal);
2204 return BAD_VALUE;
2205 }
2206
2207#undef ERROR_MSG_PREFIX
2208
2209 *type = typeVal;
2210 *id = static_cast<uint32_t>(idVal);
2211
2212 return OK;
2213}
2214
Emilian Peev71c73a22017-03-21 16:35:51 +00002215metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
2216 const std::string &name) {
2217 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
2218 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
2219 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
2220 ret = 0;
2221 }
2222
2223 return ret;
2224}
2225
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002226status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
2227 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
2228
2229 // Format must be "device@<major>.<minor>/<type>/<id>"
2230
2231#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
2232 "Should match 'device@<major>.<minor>/<type>/<id>' - "
2233
2234 if (!major || !minor || !type || !id) return INVALID_OPERATION;
2235
2236 // Verify starting prefix
2237 const char expectedPrefix[] = "device@";
2238
2239 if (name.find(expectedPrefix) != 0) {
2240 ALOGE(ERROR_MSG_PREFIX
2241 "does not start with '%s'",
2242 __FUNCTION__, name.c_str(), expectedPrefix);
2243 return BAD_VALUE;
2244 }
2245
2246 // Extract major/minor versions
2247 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
2248 std::string::size_type dotIdx = name.find('.', atIdx);
2249 if (dotIdx == std::string::npos) {
2250 ALOGE(ERROR_MSG_PREFIX
2251 "does not have @<major>. version section",
2252 __FUNCTION__, name.c_str());
2253 return BAD_VALUE;
2254 }
2255 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
2256 if (typeSlashIdx == std::string::npos) {
2257 ALOGE(ERROR_MSG_PREFIX
2258 "does not have .<minor>/ version section",
2259 __FUNCTION__, name.c_str());
2260 return BAD_VALUE;
2261 }
2262
2263 char *endPtr;
2264 errno = 0;
2265 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
2266 if (errno != 0) {
2267 ALOGE(ERROR_MSG_PREFIX
2268 "cannot parse major version: %s (%d)",
2269 __FUNCTION__, name.c_str(), strerror(errno), errno);
2270 return BAD_VALUE;
2271 }
2272 if (endPtr != name.c_str() + dotIdx) {
2273 ALOGE(ERROR_MSG_PREFIX
2274 "major version has unexpected length",
2275 __FUNCTION__, name.c_str());
2276 return BAD_VALUE;
2277 }
2278 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
2279 if (errno != 0) {
2280 ALOGE(ERROR_MSG_PREFIX
2281 "cannot parse minor version: %s (%d)",
2282 __FUNCTION__, name.c_str(), strerror(errno), errno);
2283 return BAD_VALUE;
2284 }
2285 if (endPtr != name.c_str() + typeSlashIdx) {
2286 ALOGE(ERROR_MSG_PREFIX
2287 "minor version has unexpected length",
2288 __FUNCTION__, name.c_str());
2289 return BAD_VALUE;
2290 }
2291 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
2292 ALOGE(ERROR_MSG_PREFIX
2293 "major/minor version is out of range of uint16_t: %ld.%ld",
2294 __FUNCTION__, name.c_str(), majorVal, minorVal);
2295 return BAD_VALUE;
2296 }
2297
2298 // Extract type and id
2299
2300 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
2301 if (instanceSlashIdx == std::string::npos) {
2302 ALOGE(ERROR_MSG_PREFIX
2303 "does not have /<type>/ component",
2304 __FUNCTION__, name.c_str());
2305 return BAD_VALUE;
2306 }
2307 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
2308
2309 if (instanceSlashIdx == name.size() - 1) {
2310 ALOGE(ERROR_MSG_PREFIX
2311 "does not have an /<id> component",
2312 __FUNCTION__, name.c_str());
2313 return BAD_VALUE;
2314 }
2315 std::string idVal = name.substr(instanceSlashIdx + 1);
2316
2317#undef ERROR_MSG_PREFIX
2318
2319 *major = static_cast<uint16_t>(majorVal);
2320 *minor = static_cast<uint16_t>(minorVal);
2321 *type = typeVal;
2322 *id = idVal;
2323
2324 return OK;
2325}
2326
2327
2328
2329CameraProviderManager::ProviderInfo::~ProviderInfo() {
2330 // Destruction of ProviderInfo is only supposed to happen when the respective
2331 // CameraProvider interface dies, so do not unregister callbacks.
2332
2333}
2334
2335status_t CameraProviderManager::mapToStatusT(const Status& s) {
2336 switch(s) {
2337 case Status::OK:
2338 return OK;
2339 case Status::ILLEGAL_ARGUMENT:
2340 return BAD_VALUE;
2341 case Status::CAMERA_IN_USE:
2342 return -EBUSY;
2343 case Status::MAX_CAMERAS_IN_USE:
2344 return -EUSERS;
2345 case Status::METHOD_NOT_SUPPORTED:
2346 return UNKNOWN_TRANSACTION;
2347 case Status::OPERATION_NOT_SUPPORTED:
2348 return INVALID_OPERATION;
2349 case Status::CAMERA_DISCONNECTED:
2350 return DEAD_OBJECT;
2351 case Status::INTERNAL_ERROR:
2352 return INVALID_OPERATION;
2353 }
2354 ALOGW("Unexpected HAL status code %d", s);
2355 return INVALID_OPERATION;
2356}
2357
2358const char* CameraProviderManager::statusToString(const Status& s) {
2359 switch(s) {
2360 case Status::OK:
2361 return "OK";
2362 case Status::ILLEGAL_ARGUMENT:
2363 return "ILLEGAL_ARGUMENT";
2364 case Status::CAMERA_IN_USE:
2365 return "CAMERA_IN_USE";
2366 case Status::MAX_CAMERAS_IN_USE:
2367 return "MAX_CAMERAS_IN_USE";
2368 case Status::METHOD_NOT_SUPPORTED:
2369 return "METHOD_NOT_SUPPORTED";
2370 case Status::OPERATION_NOT_SUPPORTED:
2371 return "OPERATION_NOT_SUPPORTED";
2372 case Status::CAMERA_DISCONNECTED:
2373 return "CAMERA_DISCONNECTED";
2374 case Status::INTERNAL_ERROR:
2375 return "INTERNAL_ERROR";
2376 }
2377 ALOGW("Unexpected HAL status code %d", s);
2378 return "UNKNOWN_ERROR";
2379}
2380
2381const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
2382 switch(s) {
2383 case CameraDeviceStatus::NOT_PRESENT:
2384 return "NOT_PRESENT";
2385 case CameraDeviceStatus::PRESENT:
2386 return "PRESENT";
2387 case CameraDeviceStatus::ENUMERATING:
2388 return "ENUMERATING";
2389 }
2390 ALOGW("Unexpected HAL device status code %d", s);
2391 return "UNKNOWN_STATUS";
2392}
2393
2394const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
2395 switch(s) {
2396 case TorchModeStatus::NOT_AVAILABLE:
2397 return "NOT_AVAILABLE";
2398 case TorchModeStatus::AVAILABLE_OFF:
2399 return "AVAILABLE_OFF";
2400 case TorchModeStatus::AVAILABLE_ON:
2401 return "AVAILABLE_ON";
2402 }
2403 ALOGW("Unexpected HAL torch mode status code %d", s);
2404 return "UNKNOWN_STATUS";
2405}
2406
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002407
2408status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002409 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002410 /*out*/
2411 sp<VendorTagDescriptor>& descriptor) {
2412
2413 int tagCount = 0;
2414
2415 for (size_t s = 0; s < vts.size(); s++) {
2416 tagCount += vts[s].tags.size();
2417 }
2418
2419 if (tagCount < 0 || tagCount > INT32_MAX) {
2420 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
2421 return BAD_VALUE;
2422 }
2423
2424 Vector<uint32_t> tagArray;
2425 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
2426 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
2427
2428
2429 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
2430 desc->mTagCount = tagCount;
2431
2432 SortedVector<String8> sections;
2433 KeyedVector<uint32_t, String8> tagToSectionMap;
2434
2435 int idx = 0;
2436 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002437 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002438 const char *sectionName = section.sectionName.c_str();
2439 if (sectionName == NULL) {
2440 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
2441 return BAD_VALUE;
2442 }
2443 String8 sectionString(sectionName);
2444 sections.add(sectionString);
2445
2446 for (size_t j = 0; j < section.tags.size(); j++) {
2447 uint32_t tag = section.tags[j].tagId;
2448 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
2449 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
2450 return BAD_VALUE;
2451 }
2452
2453 tagArray.editItemAt(idx++) = section.tags[j].tagId;
2454
2455 const char *tagName = section.tags[j].tagName.c_str();
2456 if (tagName == NULL) {
2457 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
2458 return BAD_VALUE;
2459 }
2460 desc->mTagToNameMap.add(tag, String8(tagName));
2461 tagToSectionMap.add(tag, sectionString);
2462
2463 int tagType = (int) section.tags[j].tagType;
2464 if (tagType < 0 || tagType >= NUM_TYPES) {
2465 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
2466 return BAD_VALUE;
2467 }
2468 desc->mTagToTypeMap.add(tag, tagType);
2469 }
2470 }
2471
2472 desc->mSections = sections;
2473
2474 for (size_t i = 0; i < tagArray.size(); ++i) {
2475 uint32_t tag = tagArray[i];
2476 String8 sectionString = tagToSectionMap.valueFor(tag);
2477
2478 // Set up tag to section index map
2479 ssize_t index = sections.indexOf(sectionString);
2480 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
2481 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
2482
2483 // Set up reverse mapping
2484 ssize_t reverseIndex = -1;
2485 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
2486 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
2487 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
2488 }
2489 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
2490 }
2491
George Burgess IVa0b84962017-08-29 17:46:19 -07002492 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002493 return OK;
2494}
2495
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002496status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
2497 CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002498 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
2499 if (deviceInfo != nullptr) {
2500 return deviceInfo->getCameraCharacteristics(characteristics);
2501 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002502
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002503 // Find hidden physical camera characteristics
2504 for (auto& provider : mProviders) {
2505 for (auto& deviceInfo : provider->mDevices) {
2506 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
2507 if (res != NAME_NOT_FOUND) return res;
2508 }
2509 }
2510
2511 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002512}
2513
2514void CameraProviderManager::filterLogicalCameraIdsLocked(
2515 std::vector<std::string>& deviceIds) const
2516{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002517 // Map between camera facing and camera IDs related to logical camera.
2518 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002519
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002520 // Collect all logical and its underlying physical camera IDs for each
2521 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002522 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002523 auto deviceInfo = findDeviceInfoLocked(deviceId);
2524 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002525
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002526 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002527 continue;
2528 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002529
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002530 // combo contains the ids of a logical camera and its physical cameras
2531 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
2532 combo.push_back(deviceId);
2533
2534 hardware::CameraInfo info;
2535 status_t res = deviceInfo->getCameraInfo(&info);
2536 if (res != OK) {
2537 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
2538 continue;
2539 }
2540 idCombos[info.facing].insert(combo.begin(), combo.end());
2541 }
2542
2543 // Only expose one camera ID per facing for all logical and underlying
2544 // physical camera IDs.
2545 for (auto& r : idCombos) {
2546 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002547 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002548 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
2549 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002550 continue;
2551 }
2552
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002553 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002554 break;
2555 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002556 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
2557 [&removedIds](const std::string& s) {
2558 return removedIds.find(s) != removedIds.end();}),
2559 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002560 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002561}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002562
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002563} // namespace android