blob: 91fc48351cad35d1e1a69428910577457a8e9b03 [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 Wang83bff122020-11-20 15:51:39 -080023#include <android/hardware/camera/device/3.7/ICameraDevice.h>
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070024
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>
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070031#include <android/hidl/manager/1.2/IServiceManager.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080032#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000033#include <functional>
34#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080035#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070036#include <android-base/logging.h>
37#include <cutils/properties.h>
38#include <hwbinder/IPCThreadState.h>
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080039#include <utils/SessionConfigurationUtils.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070040#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"
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -080043#include "device3/ZoomRatioMapper.h"
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080044
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080045namespace android {
46
47using namespace ::android::hardware::camera;
48using namespace ::android::hardware::camera::common::V1_0;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070049using camera3::SessionConfigurationUtils;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070050using std::literals::chrono_literals::operator""s;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080051using hardware::camera2::utils::CameraIdAndSessionConfiguration;
Shuzhen Wang83bff122020-11-20 15:51:39 -080052using hardware::camera::provider::V2_7::CameraIdAndStreamCombination;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080053
54namespace {
Peter Kalauskasa29c1352018-10-10 12:05:42 -070055const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080056} // anonymous namespace
57
Emilian Peev538c90e2018-12-17 18:03:19 +000058const float CameraProviderManager::kDepthARTolerance = .1f;
59
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080060CameraProviderManager::HardwareServiceInteractionProxy
61CameraProviderManager::sHardwareServiceInteractionProxy{};
62
63CameraProviderManager::~CameraProviderManager() {
64}
65
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070066hardware::hidl_vec<hardware::hidl_string>
67CameraProviderManager::HardwareServiceInteractionProxy::listServices() {
68 hardware::hidl_vec<hardware::hidl_string> ret;
69 auto manager = hardware::defaultServiceManager1_2();
70 if (manager != nullptr) {
71 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
72 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
73 ret = registered;
74 });
75 }
76 return ret;
77}
78
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080079status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
80 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080081 std::lock_guard<std::mutex> lock(mInterfaceMutex);
82 if (proxy == nullptr) {
83 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
84 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080085 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080086 mListener = listener;
87 mServiceProxy = proxy;
Eino-Ville Talvala63f36112018-12-06 14:57:03 -080088 mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
89 provider::V2_5::DeviceState::NORMAL);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080090
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080091 // Registering will trigger notifications for all already-known providers
92 bool success = mServiceProxy->registerForNotifications(
93 /* instance name, empty means no filter */ "",
94 this);
95 if (!success) {
96 ALOGE("%s: Unable to register with hardware service manager for notifications "
97 "about camera providers", __FUNCTION__);
98 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080099 }
Emilian Peev5d7e5152017-02-22 15:37:48 +0000100
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -0700101
102 for (const auto& instance : mServiceProxy->listServices()) {
103 this->addProviderLocked(instance);
104 }
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800105
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700106 IPCThreadState::self()->flushCommands();
107
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800108 return OK;
109}
110
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700111std::pair<int, int> CameraProviderManager::getCameraCount() const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800112 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700113 int systemCameraCount = 0;
114 int publicCameraCount = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800115 for (auto& provider : mProviders) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700116 for (auto &id : provider->mUniqueCameraIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700117 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
118 if (getSystemCameraKindLocked(id, &deviceKind) != OK) {
119 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, id.c_str());
120 continue;
121 }
122 switch(deviceKind) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700123 case SystemCameraKind::PUBLIC:
124 publicCameraCount++;
125 break;
126 case SystemCameraKind::SYSTEM_ONLY_CAMERA:
127 systemCameraCount++;
128 break;
129 default:
130 break;
131 }
132 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800133 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700134 return std::make_pair(systemCameraCount, publicCameraCount);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800135}
136
137std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
138 std::lock_guard<std::mutex> lock(mInterfaceMutex);
139 std::vector<std::string> deviceIds;
140 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700141 for (auto& id : provider->mUniqueCameraIds) {
142 deviceIds.push_back(id);
143 }
144 }
145 return deviceIds;
146}
147
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700148void CameraProviderManager::collectDeviceIdsLocked(const std::vector<std::string> deviceIds,
149 std::vector<std::string>& publicDeviceIds,
150 std::vector<std::string>& systemDeviceIds) const {
151 for (auto &deviceId : deviceIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700152 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
153 if (getSystemCameraKindLocked(deviceId, &deviceKind) != OK) {
154 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, deviceId.c_str());
155 continue;
156 }
157 if (deviceKind == SystemCameraKind::SYSTEM_ONLY_CAMERA) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700158 systemDeviceIds.push_back(deviceId);
159 } else {
160 publicDeviceIds.push_back(deviceId);
161 }
162 }
163}
164
Emilian Peevf53f66e2017-04-11 14:29:43 +0100165std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700166 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700167 std::vector<std::string> publicDeviceIds;
168 std::vector<std::string> systemDeviceIds;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700169 std::vector<std::string> deviceIds;
170 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700171 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700172 // Secure cameras should not be exposed through camera 1 api
173 providerDeviceIds.erase(std::remove_if(providerDeviceIds.begin(), providerDeviceIds.end(),
174 [this](const std::string& s) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700175 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
176 if (getSystemCameraKindLocked(s, &deviceKind) != OK) {
177 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, s.c_str());
178 return true;
179 }
180 return deviceKind == SystemCameraKind::HIDDEN_SECURE_CAMERA;}),
181 providerDeviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700182 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700183 // for each camera facing, only take the first id advertised by HAL in
184 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700185 filterLogicalCameraIdsLocked(providerDeviceIds);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700186 collectDeviceIdsLocked(providerDeviceIds, publicDeviceIds, systemDeviceIds);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800187 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700188 auto sortFunc =
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800189 [](const std::string& a, const std::string& b) -> bool {
190 uint32_t aUint = 0, bUint = 0;
191 bool aIsUint = base::ParseUint(a, &aUint);
192 bool bIsUint = base::ParseUint(b, &bUint);
193
194 // Uint device IDs first
195 if (aIsUint && bIsUint) {
196 return aUint < bUint;
197 } else if (aIsUint) {
198 return true;
199 } else if (bIsUint) {
200 return false;
201 }
202 // Simple string compare if both id are not uint
203 return a < b;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700204 };
205 // We put device ids for system cameras at the end since they will be pared
206 // off for processes not having system camera permissions.
207 std::sort(publicDeviceIds.begin(), publicDeviceIds.end(), sortFunc);
208 std::sort(systemDeviceIds.begin(), systemDeviceIds.end(), sortFunc);
209 deviceIds.insert(deviceIds.end(), publicDeviceIds.begin(), publicDeviceIds.end());
210 deviceIds.insert(deviceIds.end(), systemDeviceIds.begin(), systemDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800211 return deviceIds;
212}
213
214bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
215 std::lock_guard<std::mutex> lock(mInterfaceMutex);
216 return isValidDeviceLocked(id, majorVersion);
217}
218
219bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
220 for (auto& provider : mProviders) {
221 for (auto& deviceInfo : provider->mDevices) {
222 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
223 return true;
224 }
225 }
226 }
227 return false;
228}
229
230bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
231 std::lock_guard<std::mutex> lock(mInterfaceMutex);
232
233 auto deviceInfo = findDeviceInfoLocked(id);
234 if (deviceInfo == nullptr) return false;
235
236 return deviceInfo->hasFlashUnit();
237}
238
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800239bool CameraProviderManager::supportNativeZoomRatio(const std::string &id) const {
240 std::lock_guard<std::mutex> lock(mInterfaceMutex);
241
242 auto deviceInfo = findDeviceInfoLocked(id);
243 if (deviceInfo == nullptr) return false;
244
245 return deviceInfo->supportNativeZoomRatio();
246}
247
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800248status_t CameraProviderManager::getResourceCost(const std::string &id,
249 CameraResourceCost* cost) const {
250 std::lock_guard<std::mutex> lock(mInterfaceMutex);
251
252 auto deviceInfo = findDeviceInfoLocked(id);
253 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
254
255 *cost = deviceInfo->mResourceCost;
256 return OK;
257}
258
259status_t CameraProviderManager::getCameraInfo(const std::string &id,
260 hardware::CameraInfo* info) const {
261 std::lock_guard<std::mutex> lock(mInterfaceMutex);
262
263 auto deviceInfo = findDeviceInfoLocked(id);
264 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
265
266 return deviceInfo->getCameraInfo(info);
267}
268
Emilian Peev35ae8262018-11-08 13:11:32 +0000269status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800270 const hardware::camera::device::V3_7::StreamConfiguration &configuration,
Emilian Peev35ae8262018-11-08 13:11:32 +0000271 bool *status /*out*/) const {
272 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Emilian Peev35ae8262018-11-08 13:11:32 +0000273 auto deviceInfo = findDeviceInfoLocked(id);
274 if (deviceInfo == nullptr) {
275 return NAME_NOT_FOUND;
276 }
277
278 return deviceInfo->isSessionConfigurationSupported(configuration, status);
279}
280
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800281status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700282 bool overrideForPerfClass, CameraMetadata* characteristics) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800283 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700284 return getCameraCharacteristicsLocked(id, overrideForPerfClass, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800285}
286
287status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
288 hardware::hidl_version *v) {
289 std::lock_guard<std::mutex> lock(mInterfaceMutex);
290
291 hardware::hidl_version maxVersion{0,0};
292 bool found = false;
293 for (auto& provider : mProviders) {
294 for (auto& deviceInfo : provider->mDevices) {
295 if (deviceInfo->mId == id) {
296 if (deviceInfo->mVersion > maxVersion) {
297 maxVersion = deviceInfo->mVersion;
298 found = true;
299 }
300 }
301 }
302 }
303 if (!found) {
304 return NAME_NOT_FOUND;
305 }
306 *v = maxVersion;
307 return OK;
308}
309
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700310bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700311 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700312 for (auto& provider : mProviders) {
313 auto deviceInfo = findDeviceInfoLocked(id);
314 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700315 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700316 }
317 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700318 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700319}
320
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800321status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
322 std::lock_guard<std::mutex> lock(mInterfaceMutex);
323
324 auto deviceInfo = findDeviceInfoLocked(id);
325 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
326
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700327 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
328 // that are currently in use.
Shuzhen Wang79680432020-03-05 11:53:46 -0800329 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
330 if (parentProvider == nullptr) {
331 return DEAD_OBJECT;
332 }
333 const sp<provider::V2_4::ICameraProvider> interface = parentProvider->startProviderInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700334 if (interface == nullptr) {
335 return DEAD_OBJECT;
336 }
337 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
338
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800339 return deviceInfo->setTorchMode(enabled);
340}
341
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800342status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000343 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
344
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800345 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800346 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800347 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000348
349 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
350
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800351 return OK;
352}
353
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800354status_t CameraProviderManager::notifyDeviceStateChange(
355 hardware::hidl_bitfield<provider::V2_5::DeviceState> newState) {
356 std::lock_guard<std::mutex> lock(mInterfaceMutex);
357 mDeviceState = newState;
358 status_t res = OK;
359 for (auto& provider : mProviders) {
360 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
361 __FUNCTION__, provider->mProviderName.c_str(), newState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700362 // b/199240726 Camera providers can for example try to add/remove
363 // camera devices as part of the state change notification. Holding
364 // 'mInterfaceMutex' while calling 'notifyDeviceStateChange' can
365 // result in a recursive deadlock.
366 mInterfaceMutex.unlock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800367 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700368 mInterfaceMutex.lock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800369 if (singleRes != OK) {
370 ALOGE("%s: Unable to notify provider %s about device state change",
371 __FUNCTION__,
372 provider->mProviderName.c_str());
373 res = singleRes;
374 // continue to do the rest of the providers instead of returning now
375 }
Emilian Peevb50402e2021-09-24 17:41:57 -0700376 provider->notifyDeviceInfoStateChangeLocked(mDeviceState);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800377 }
378 return res;
379}
380
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800381status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800382 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800383 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800384 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800385
386 std::lock_guard<std::mutex> lock(mInterfaceMutex);
387
388 auto deviceInfo = findDeviceInfoLocked(id,
389 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
390 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
391
392 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Shuzhen Wang79680432020-03-05 11:53:46 -0800393 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
394 if (parentProvider == nullptr) {
395 return DEAD_OBJECT;
396 }
397 const sp<provider::V2_4::ICameraProvider> provider = parentProvider->startProviderInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700398 if (provider == nullptr) {
399 return DEAD_OBJECT;
400 }
401 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800402
403 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700404 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700405 auto interface = deviceInfo3->startDeviceInterface<
406 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
407 if (interface == nullptr) {
408 return DEAD_OBJECT;
409 }
410
411 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800412 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
413 status = s;
414 if (status == Status::OK) {
415 *session = cameraSession;
416 }
417 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700418 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700419 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700420 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
421 __FUNCTION__, id.c_str(), ret.description().c_str());
422 return DEAD_OBJECT;
423 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800424 return mapToStatusT(status);
425}
426
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700427void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
428 sp<provider::V2_4::ICameraProvider> provider) {
429 if (!kEnableLazyHal) {
430 return;
431 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800432 ALOGV("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700433 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
434 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
435 if (usageType == DeviceMode::TORCH) {
436 primaryMap = &mTorchProviderByCameraId;
437 alternateMap = &mCameraProviderByCameraId;
438 } else {
439 primaryMap = &mCameraProviderByCameraId;
440 alternateMap = &mTorchProviderByCameraId;
441 }
442 auto id = cameraId.c_str();
443 (*primaryMap)[id] = provider;
444 auto search = alternateMap->find(id);
445 if (search != alternateMap->end()) {
446 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
447 "That should not be possible", __FUNCTION__, id);
448 }
449 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
450}
451
452void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
453 if (!kEnableLazyHal) {
454 return;
455 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800456 ALOGV("Removing camera device %s", cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700457 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
458 if (usageType == DeviceMode::TORCH) {
459 providerMap = &mTorchProviderByCameraId;
460 } else {
461 providerMap = &mCameraProviderByCameraId;
462 }
463 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
464 auto search = providerMap->find(cameraId.c_str());
465 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800466 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
467 // added delay) because hwservicemanager guarantees to hold the reference for at least five
468 // more seconds. We depend on this behavior so that if the provider is unreferenced and
469 // then referenced again quickly, we do not let the HAL exit and then need to immediately
470 // restart it. An example when this could happen is switching from a front-facing to a
471 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
472 // appear janky to the user.
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700473 providerMap->erase(cameraId.c_str());
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800474 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700475 } else {
476 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
477 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
478 cameraId.c_str());
479 }
480}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800481
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800482hardware::Return<void> CameraProviderManager::onRegistration(
483 const hardware::hidl_string& /*fqName*/,
484 const hardware::hidl_string& name,
Emilian Peevc93cac22020-08-17 16:00:10 -0700485 bool preexisting) {
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700486 status_t res = OK;
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700487 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100488 {
489 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800490
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700491 res = addProviderLocked(name, preexisting);
Emilian Peevaee727d2017-05-04 16:35:48 +0100492 }
493
494 sp<StatusListener> listener = getStatusListener();
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700495 if (nullptr != listener.get() && res == OK) {
Emilian Peevaee727d2017-05-04 16:35:48 +0100496 listener->onNewProviderRegistered();
497 }
498
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700499 IPCThreadState::self()->flushCommands();
500
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800501 return hardware::Return<void>();
502}
503
504status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
505 std::lock_guard<std::mutex> lock(mInterfaceMutex);
506
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800507 for (auto& provider : mProviders) {
508 provider->dump(fd, args);
509 }
510 return OK;
511}
512
513CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800514 const std::string& id,
515 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800516 for (auto& provider : mProviders) {
517 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800518 if (deviceInfo->mId == id &&
519 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800520 return deviceInfo.get();
521 }
522 }
523 }
524 return nullptr;
525}
526
Emilian Peev71c73a22017-03-21 16:35:51 +0000527metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
528 const std::string& id, hardware::hidl_version minVersion,
529 hardware::hidl_version maxVersion) const {
530 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
531
532 std::lock_guard<std::mutex> lock(mInterfaceMutex);
533 for (auto& provider : mProviders) {
534 for (auto& deviceInfo : provider->mDevices) {
535 if (deviceInfo->mId == id &&
536 minVersion <= deviceInfo->mVersion &&
537 maxVersion >= deviceInfo->mVersion) {
538 return provider->mProviderTagid;
539 }
540 }
541 }
542
543 return ret;
544}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800545
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700546void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
547 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700548
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700549 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700550 for (size_t i = 0; i < entryCap.count; ++i) {
551 uint8_t capability = entryCap.data.u8[i];
552 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700553 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700554 break;
555 }
556 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700557 if (!mIsLogicalCamera) {
558 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700559 }
560
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700561 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
562 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700563 const uint8_t* ids = entryIds.data.u8;
564 size_t start = 0;
565 for (size_t i = 0; i < entryIds.count; ++i) {
566 if (ids[i] == '\0') {
567 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700568 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700569 }
570 start = i+1;
571 }
572 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700573}
574
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700575SystemCameraKind CameraProviderManager::ProviderInfo::DeviceInfo3::getSystemCameraKind() {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800576 camera_metadata_entry_t entryCap;
577 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700578 if (entryCap.count == 1 &&
579 entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
580 return SystemCameraKind::HIDDEN_SECURE_CAMERA;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800581 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700582
583 // Go through the capabilities and check if it has
584 // ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA
585 for (size_t i = 0; i < entryCap.count; ++i) {
586 uint8_t capability = entryCap.data.u8[i];
587 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA) {
588 return SystemCameraKind::SYSTEM_ONLY_CAMERA;
589 }
590 }
591 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800592}
593
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000594void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
595 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
596 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
597 if (sizes == nullptr) {
598 return;
599 }
600
601 auto scalerDims = ch.find(tag);
602 if (scalerDims.count > 0) {
603 // Scaler entry contains 4 elements (format, width, height, type)
604 for (size_t i = 0; i < scalerDims.count; i += 4) {
605 if ((scalerDims.data.i32[i] == format) &&
606 (scalerDims.data.i32[i+3] ==
607 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
608 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
609 scalerDims.data.i32[i+2]));
610 }
611 }
612 }
613}
614
615void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
616 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
617 const std::vector<std::tuple<size_t, size_t>>& sizes,
618 std::vector<int64_t> *durations/*out*/) {
619 if (durations == nullptr) {
620 return;
621 }
622
623 auto availableDurations = ch.find(tag);
624 if (availableDurations.count > 0) {
625 // Duration entry contains 4 elements (format, width, height, duration)
626 for (size_t i = 0; i < availableDurations.count; i += 4) {
627 for (const auto& size : sizes) {
628 int64_t width = std::get<0>(size);
629 int64_t height = std::get<1>(size);
630 if ((availableDurations.data.i64[i] == format) &&
631 (availableDurations.data.i64[i+1] == width) &&
632 (availableDurations.data.i64[i+2] == height)) {
633 durations->push_back(availableDurations.data.i64[i+3]);
634 }
635 }
636 }
637 }
638}
639void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
640 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
641 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
642 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
643 return;
644 }
645
646 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
647 // Processing time on camera service side can vary greatly depending on multiple
648 // variables which are not under our control. Make a guesstimate by taking the maximum
649 // corresponding duration value from depth and blob.
650 auto depthDuration = depthDurations.begin();
651 auto blobDuration = blobDurations.begin();
652 dynamicDepthDurations->reserve(depthDurations.size());
653 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
654 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
655 depthDuration++; blobDuration++;
656 }
657}
658
659void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
660 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
661 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
662 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
663 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
664 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
665 return;
666 }
667
668 // The dynamic depth spec. does not mention how close the AR ratio should be.
669 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000670 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000671
672 for (const auto& blobSize : blobSizes) {
673 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
674 static_cast<float>(std::get<1>(blobSize));
675 bool found = false;
676 for (const auto& depthSize : depthSizes) {
677 if (depthSize == blobSize) {
678 internalDepthSizes->push_back(depthSize);
679 found = true;
680 break;
681 } else {
682 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
683 static_cast<float>(std::get<1>(depthSize));
684 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
685 internalDepthSizes->push_back(depthSize);
686 found = true;
687 break;
688 }
689 }
690 }
691
692 if (found) {
693 dynamicDepthSizes->push_back(blobSize);
694 }
695 }
696}
697
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800698status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags(
699 bool maxResolution) {
700 const int32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
701
702 const int32_t scalerSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700703 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800704 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
705 const int32_t scalerMinFrameDurationsTag =
706 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
707 const int32_t scalerStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700708 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800709 ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, maxResolution);
710
711 const int32_t depthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700712 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800713 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
714 const int32_t depthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700715 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800716 ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, maxResolution);
717 const int32_t depthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700718 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800719 ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
720
721 const int32_t dynamicDepthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700722 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800723 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
724 const int32_t dynamicDepthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700725 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800726 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS, maxResolution);
727 const int32_t dynamicDepthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700728 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800729 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
730
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000731 auto& c = mCameraCharacteristics;
732 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
733 supportedDynamicDepthSizes, internalDepthSizes;
734 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
735 if (chTags.count == 0) {
736 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
737 return BAD_VALUE;
738 }
739
740 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
741 depthExclTag) != (chTags.data.i32 + chTags.count);
742 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -0800743 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000744 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
745 // No depth support, nothing more to do.
746 return OK;
747 }
748
749 auto depthExclusiveEntry = c.find(depthExclTag);
750 if (depthExclusiveEntry.count > 0) {
751 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
752 // Depth support is exclusive, nothing more to do.
753 return OK;
754 }
755 } else {
756 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
757 return BAD_VALUE;
758 }
759
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800760 getSupportedSizes(c, scalerSizesTag, HAL_PIXEL_FORMAT_BLOB,
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000761 &supportedBlobSizes);
762 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
763 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
764 // Nothing to do in this case.
765 return OK;
766 }
767
768 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
769 &supportedDynamicDepthSizes, &internalDepthSizes);
770 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000771 // Nothing more to do.
772 return OK;
773 }
774
775 std::vector<int32_t> dynamicDepthEntries;
776 for (const auto& it : supportedDynamicDepthSizes) {
777 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
778 static_cast<int32_t> (std::get<1>(it)),
779 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
780 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
781 }
782
783 std::vector<int64_t> depthMinDurations, depthStallDurations;
784 std::vector<int64_t> blobMinDurations, blobStallDurations;
785 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
786
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800787 getSupportedDurations(c, depthMinFrameDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
788 &depthMinDurations);
789 getSupportedDurations(c, scalerMinFrameDurationsTag, HAL_PIXEL_FORMAT_BLOB,
790 supportedDynamicDepthSizes, &blobMinDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000791 if (blobMinDurations.empty() || depthMinDurations.empty() ||
792 (depthMinDurations.size() != blobMinDurations.size())) {
793 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
794 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
795 return BAD_VALUE;
796 }
797
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800798 getSupportedDurations(c, depthStallDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
799 &depthStallDurations);
800 getSupportedDurations(c, scalerStallDurationsTag, HAL_PIXEL_FORMAT_BLOB,
801 supportedDynamicDepthSizes, &blobStallDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000802 if (blobStallDurations.empty() || depthStallDurations.empty() ||
803 (depthStallDurations.size() != blobStallDurations.size())) {
804 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
805 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
806 return BAD_VALUE;
807 }
808
809 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
810 &dynamicDepthMinDurations);
811 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
812 &dynamicDepthStallDurations);
813 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
814 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
815 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
816 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
817 return BAD_VALUE;
818 }
819
820 std::vector<int64_t> dynamicDepthMinDurationEntries;
821 auto itDuration = dynamicDepthMinDurations.begin();
822 auto itSize = supportedDynamicDepthSizes.begin();
823 while (itDuration != dynamicDepthMinDurations.end()) {
824 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
825 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
826 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
827 entry + 4);
828 itDuration++; itSize++;
829 }
830
831 std::vector<int64_t> dynamicDepthStallDurationEntries;
832 itDuration = dynamicDepthStallDurations.begin();
833 itSize = supportedDynamicDepthSizes.begin();
834 while (itDuration != dynamicDepthStallDurations.end()) {
835 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
836 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
837 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
838 entry + 4);
839 itDuration++; itSize++;
840 }
841
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000842 std::vector<int32_t> supportedChTags;
843 supportedChTags.reserve(chTags.count + 3);
844 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
845 chTags.data.i32 + chTags.count);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800846 supportedChTags.push_back(dynamicDepthSizesTag);
847 supportedChTags.push_back(dynamicDepthMinFrameDurationsTag);
848 supportedChTags.push_back(dynamicDepthStallDurationsTag);
849 c.update(dynamicDepthSizesTag, dynamicDepthEntries.data(), dynamicDepthEntries.size());
850 c.update(dynamicDepthMinFrameDurationsTag, dynamicDepthMinDurationEntries.data(),
851 dynamicDepthMinDurationEntries.size());
852 c.update(dynamicDepthStallDurationsTag, dynamicDepthStallDurationEntries.data(),
853 dynamicDepthStallDurationEntries.size());
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000854 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
855 supportedChTags.size());
856
857 return OK;
858}
859
Shuzhen Wang268a1362018-10-16 16:32:59 -0700860status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
861 status_t res = OK;
862 auto& c = mCameraCharacteristics;
863
864 // Override static metadata for MONOCHROME camera with older device version
865 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
866 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
867 for (size_t i = 0; i < cap.count; i++) {
868 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
869 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
870 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
871 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
872 if (res != OK) {
873 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
874 __FUNCTION__, strerror(-res), res);
875 return res;
876 }
877
878 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
879 const std::vector<uint32_t> sKeys = {
880 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
881 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
882 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
883 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
884 ANDROID_SENSOR_COLOR_TRANSFORM1,
885 ANDROID_SENSOR_COLOR_TRANSFORM2,
886 ANDROID_SENSOR_FORWARD_MATRIX1,
887 ANDROID_SENSOR_FORWARD_MATRIX2,
888 };
889 res = removeAvailableKeys(c, sKeys,
890 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
891 if (res != OK) {
892 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
893 __FUNCTION__, strerror(-res), res);
894 return res;
895 }
896
897 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
898 const std::vector<uint32_t> reqKeys = {
899 ANDROID_COLOR_CORRECTION_MODE,
900 ANDROID_COLOR_CORRECTION_TRANSFORM,
901 ANDROID_COLOR_CORRECTION_GAINS,
902 };
903 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
904 if (res != OK) {
905 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
906 __FUNCTION__, strerror(-res), res);
907 return res;
908 }
909
910 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
911 const std::vector<uint32_t> resKeys = {
912 ANDROID_SENSOR_GREEN_SPLIT,
913 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
914 ANDROID_COLOR_CORRECTION_MODE,
915 ANDROID_COLOR_CORRECTION_TRANSFORM,
916 ANDROID_COLOR_CORRECTION_GAINS,
917 };
918 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
919 if (res != OK) {
920 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
921 __FUNCTION__, strerror(-res), res);
922 return res;
923 }
924
925 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
926 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
927 for (size_t j = 1; j < blEntry.count; j++) {
928 blEntry.data.i32[j] = blEntry.data.i32[0];
929 }
930 }
931 }
932 }
933 return res;
934}
935
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800936status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addRotateCropTags() {
937 status_t res = OK;
938 auto& c = mCameraCharacteristics;
939
940 auto availableRotateCropEntry = c.find(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES);
941 if (availableRotateCropEntry.count == 0) {
942 uint8_t defaultAvailableRotateCropEntry = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
943 res = c.update(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,
944 &defaultAvailableRotateCropEntry, 1);
945 }
946 return res;
947}
948
Shuzhen Wang9bf8a6f2020-05-01 09:49:04 -0700949status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addPreCorrectionActiveArraySize() {
950 status_t res = OK;
951 auto& c = mCameraCharacteristics;
952
953 auto activeArraySize = c.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
954 auto preCorrectionActiveArraySize = c.find(
955 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
956 if (activeArraySize.count == 4 && preCorrectionActiveArraySize.count == 0) {
957 std::vector<int32_t> preCorrectionArray(
958 activeArraySize.data.i32, activeArraySize.data.i32+4);
959 res = c.update(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
960 preCorrectionArray.data(), 4);
961 if (res != OK) {
962 ALOGE("%s: Failed to add ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s(%d)",
963 __FUNCTION__, strerror(-res), res);
964 return res;
965 }
966 } else {
967 return res;
968 }
969
970 auto charTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
971 bool hasPreCorrectionActiveArraySize = std::find(charTags.data.i32,
972 charTags.data.i32 + charTags.count,
973 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE) !=
974 (charTags.data.i32 + charTags.count);
975 if (!hasPreCorrectionActiveArraySize) {
976 std::vector<int32_t> supportedCharTags;
977 supportedCharTags.reserve(charTags.count + 1);
978 supportedCharTags.insert(supportedCharTags.end(), charTags.data.i32,
979 charTags.data.i32 + charTags.count);
980 supportedCharTags.push_back(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
981
982 res = c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedCharTags.data(),
983 supportedCharTags.size());
984 if (res != OK) {
985 ALOGE("%s: Failed to update ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s(%d)",
986 __FUNCTION__, strerror(-res), res);
987 return res;
988 }
989 }
990
991 return res;
992}
993
Shuzhen Wang268a1362018-10-16 16:32:59 -0700994status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
995 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
996 status_t res = OK;
997
998 camera_metadata_entry keysEntry = c.find(keyTag);
999 if (keysEntry.count == 0) {
1000 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
1001 return res;
1002 }
1003 std::vector<int32_t> vKeys;
1004 vKeys.reserve(keysEntry.count);
1005 for (size_t i = 0; i < keysEntry.count; i++) {
1006 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
1007 vKeys.push_back(keysEntry.data.i32[i]);
1008 }
1009 }
1010 res = c.update(keyTag, vKeys.data(), vKeys.size());
1011 return res;
1012}
1013
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001014status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
1015 std::vector<int32_t>* outputs,
1016 std::vector<int64_t>* durations,
1017 std::vector<int64_t>* stallDurations,
1018 const camera_metadata_entry& halStreamConfigs,
1019 const camera_metadata_entry& halStreamDurations) {
1020 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
1021 return BAD_VALUE;
1022 }
1023
1024 static bool supportInMemoryTempFile =
1025 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
1026 if (!supportInMemoryTempFile) {
1027 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
1028 __FUNCTION__);
1029 return OK;
1030 }
1031
1032 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
1033 int32_t format = halStreamConfigs.data.i32[i];
1034 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
1035 // image.
1036 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
1037 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
1038 continue;
1039 }
1040
1041 bool sizeAvail = false;
1042 for (size_t j = 0; j < outputs->size(); j+= 4) {
1043 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
1044 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
1045 sizeAvail = true;
1046 break;
1047 }
1048 }
1049 if (sizeAvail) continue;
1050
1051 int64_t stall = 0;
Susmitha Gummallafca67142020-03-05 14:58:30 -08001052 bool useHeic = false;
1053 bool useGrid = false;
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001054 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
1055 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
1056 &useHeic, &useGrid, &stall)) {
1057 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
1058 continue;
1059 }
1060
1061 // HEIC configuration
1062 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1063 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
1064 outputs->insert(outputs->end(), config, config + 4);
1065
1066 // HEIC minFrameDuration
1067 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
1068 if (halStreamDurations.data.i64[j] == format &&
1069 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
1070 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
1071 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1072 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
1073 durations->insert(durations->end(), duration, duration+4);
1074 break;
1075 }
1076 }
1077
1078 // HEIC stallDuration
1079 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1080 halStreamConfigs.data.i32[i+2], stall};
1081 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
1082 }
1083 }
1084 return OK;
1085}
1086
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001087status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags(bool maxResolution) {
1088 int32_t scalerStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001089 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001090 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
1091 int32_t scalerMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001092 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001093 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, maxResolution);
1094
1095 int32_t heicStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001096 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001097 ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS, maxResolution);
1098 int32_t heicMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001099 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001100 ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS, maxResolution);
1101 int32_t heicStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001102 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001103 ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS, maxResolution);
1104
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001105 auto& c = mCameraCharacteristics;
1106
1107 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
1108 if (halHeicSupport.count > 1) {
1109 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
1110 __FUNCTION__, halHeicSupport.count);
1111 return BAD_VALUE;
1112 } else if (halHeicSupport.count == 0 ||
1113 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
1114 // Camera HAL doesn't support mandatory stream combinations for HEIC.
1115 return OK;
1116 }
1117
1118 camera_metadata_entry maxJpegAppsSegments =
1119 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1120 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1121 maxJpegAppsSegments.data.u8[0] > 16) {
1122 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1123 __FUNCTION__);
1124 return BAD_VALUE;
1125 }
1126
1127 // Populate HEIC output configurations and its related min frame duration
1128 // and stall duration.
1129 std::vector<int32_t> heicOutputs;
1130 std::vector<int64_t> heicDurations;
1131 std::vector<int64_t> heicStallDurations;
1132
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001133 camera_metadata_entry halStreamConfigs = c.find(scalerStreamSizesTag);
1134 camera_metadata_entry minFrameDurations = c.find(scalerMinFrameDurationsTag);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001135
1136 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
1137 halStreamConfigs, minFrameDurations);
1138 if (res != OK) {
1139 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
1140 strerror(-res), res);
1141 return res;
1142 }
1143
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001144 c.update(heicStreamSizesTag, heicOutputs.data(), heicOutputs.size());
1145 c.update(heicMinFrameDurationsTag, heicDurations.data(), heicDurations.size());
1146 c.update(heicStallDurationsTag, heicStallDurations.data(), heicStallDurations.size());
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001147
1148 return OK;
1149}
1150
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001151bool CameraProviderManager::isLogicalCameraLocked(const std::string& id,
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001152 std::vector<std::string>* physicalCameraIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001153 auto deviceInfo = findDeviceInfoLocked(id);
1154 if (deviceInfo == nullptr) return false;
1155
1156 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
1157 *physicalCameraIds = deviceInfo->mPhysicalIds;
1158 }
1159 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001160}
1161
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001162bool CameraProviderManager::isLogicalCamera(const std::string& id,
1163 std::vector<std::string>* physicalCameraIds) {
1164 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1165 return isLogicalCameraLocked(id, physicalCameraIds);
1166}
1167
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001168status_t CameraProviderManager::getSystemCameraKind(const std::string& id,
1169 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001170 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001171 return getSystemCameraKindLocked(id, kind);
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001172}
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001173
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001174status_t CameraProviderManager::getSystemCameraKindLocked(const std::string& id,
1175 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001176 auto deviceInfo = findDeviceInfoLocked(id);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001177 if (deviceInfo != nullptr) {
1178 *kind = deviceInfo->mSystemCameraKind;
1179 return OK;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001180 }
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001181 // If this is a hidden physical camera, we should return what kind of
1182 // camera the enclosing logical camera is.
1183 auto isHiddenAndParent = isHiddenPhysicalCameraInternal(id);
1184 if (isHiddenAndParent.first) {
1185 LOG_ALWAYS_FATAL_IF(id == isHiddenAndParent.second->mId,
1186 "%s: hidden physical camera id %s and enclosing logical camera id %s are the same",
1187 __FUNCTION__, id.c_str(), isHiddenAndParent.second->mId.c_str());
1188 return getSystemCameraKindLocked(isHiddenAndParent.second->mId, kind);
1189 }
1190 // Neither a hidden physical camera nor a logical camera
1191 return NAME_NOT_FOUND;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001192}
1193
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001194bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) const {
Emilian Peev7fe6c422021-09-08 13:43:20 -07001195 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001196 return isHiddenPhysicalCameraInternal(cameraId).first;
1197}
1198
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001199status_t CameraProviderManager::filterSmallJpegSizes(const std::string& cameraId) {
Emilian Peev7fe6c422021-09-08 13:43:20 -07001200 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wang89db2992021-05-20 13:09:48 -07001201 for (auto& provider : mProviders) {
1202 for (auto& deviceInfo : provider->mDevices) {
1203 if (deviceInfo->mId == cameraId) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001204 return deviceInfo->filterSmallJpegSizes();
Shuzhen Wang89db2992021-05-20 13:09:48 -07001205 }
1206 }
1207 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001208 return NAME_NOT_FOUND;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001209}
1210
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001211std::pair<bool, CameraProviderManager::ProviderInfo::DeviceInfo *>
1212CameraProviderManager::isHiddenPhysicalCameraInternal(const std::string& cameraId) const {
1213 auto falseRet = std::make_pair(false, nullptr);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001214 for (auto& provider : mProviders) {
1215 for (auto& deviceInfo : provider->mDevices) {
1216 if (deviceInfo->mId == cameraId) {
1217 // cameraId is found in public camera IDs advertised by the
1218 // provider.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001219 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001220 }
1221 }
1222 }
1223
1224 for (auto& provider : mProviders) {
1225 for (auto& deviceInfo : provider->mDevices) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001226 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001227 if (deviceInfo->mIsLogicalCamera) {
1228 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1229 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001230 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
1231 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
1232 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
1233 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
1234 __FUNCTION__, deviceVersion, cameraId.c_str());
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001235 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001236 } else {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001237 return std::make_pair(true, deviceInfo.get());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001238 }
1239 }
1240 }
1241 }
1242 }
1243
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001244 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001245}
1246
Emilian Peevc93cac22020-08-17 16:00:10 -07001247status_t CameraProviderManager::tryToInitializeProviderLocked(
1248 const std::string& providerName, const sp<ProviderInfo>& providerInfo) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001249 sp<provider::V2_4::ICameraProvider> interface;
Emilian Peevc93cac22020-08-17 16:00:10 -07001250 interface = mServiceProxy->tryGetService(providerName);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001251
1252 if (interface == nullptr) {
Shuzhen Wang77d04192021-04-02 12:33:54 -07001253 // The interface may not be started yet. In that case, this is not a
1254 // fatal error.
1255 ALOGW("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
Emilian Peevc93cac22020-08-17 16:00:10 -07001256 providerName.c_str());
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001257 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001258 }
1259
Emilian Peevc93cac22020-08-17 16:00:10 -07001260 return providerInfo->initialize(interface, mDeviceState);
1261}
1262
1263status_t CameraProviderManager::addProviderLocked(const std::string& newProvider,
1264 bool preexisting) {
1265 // Several camera provider instances can be temporarily present.
1266 // Defer initialization of a new instance until the older instance is properly removed.
1267 auto providerInstance = newProvider + "-" + std::to_string(mProviderInstanceId);
1268 bool providerPresent = false;
1269 for (const auto& providerInfo : mProviders) {
1270 if (providerInfo->mProviderName == newProvider) {
1271 ALOGW("%s: Camera provider HAL with name '%s' already registered",
1272 __FUNCTION__, newProvider.c_str());
1273 if (preexisting) {
1274 return ALREADY_EXISTS;
1275 } else{
1276 ALOGW("%s: The new provider instance will get initialized immediately after the"
1277 " currently present instance is removed!", __FUNCTION__);
1278 providerPresent = true;
1279 break;
1280 }
1281 }
1282 }
1283
1284 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, providerInstance, this);
1285 if (!providerPresent) {
1286 status_t res = tryToInitializeProviderLocked(newProvider, providerInfo);
1287 if (res != OK) {
1288 return res;
1289 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001290 }
1291
1292 mProviders.push_back(providerInfo);
Emilian Peevc93cac22020-08-17 16:00:10 -07001293 mProviderInstanceId++;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001294
1295 return OK;
1296}
1297
1298status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07001299 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001300 std::unique_lock<std::mutex> lock(mInterfaceMutex);
1301 std::vector<String8> removedDeviceIds;
1302 status_t res = NAME_NOT_FOUND;
Emilian Peevc93cac22020-08-17 16:00:10 -07001303 std::string removedProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001304 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
Emilian Peevc93cac22020-08-17 16:00:10 -07001305 if ((*it)->mProviderInstance == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001306 removedDeviceIds.reserve((*it)->mDevices.size());
1307 for (auto& deviceInfo : (*it)->mDevices) {
1308 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
1309 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001310 removedProviderName = (*it)->mProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001311 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001312 res = OK;
1313 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001314 }
1315 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001316 if (res != OK) {
1317 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1318 provider.c_str());
1319 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07001320 // Check if there are any newer camera instances from the same provider and try to
1321 // initialize.
1322 for (const auto& providerInfo : mProviders) {
1323 if (providerInfo->mProviderName == removedProviderName) {
1324 return tryToInitializeProviderLocked(removedProviderName, providerInfo);
1325 }
1326 }
1327
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001328 // Inform camera service of loss of presence for all the devices from this provider,
1329 // without lock held for reentrancy
1330 sp<StatusListener> listener = getStatusListener();
1331 if (listener != nullptr) {
1332 lock.unlock();
1333 for (auto& id : removedDeviceIds) {
1334 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1335 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001336 lock.lock();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001337 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001338
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001339 }
1340 return res;
1341}
1342
1343sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1344 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001345}
1346
1347/**** Methods for ProviderInfo ****/
1348
1349
1350CameraProviderManager::ProviderInfo::ProviderInfo(
1351 const std::string &providerName,
Emilian Peevc93cac22020-08-17 16:00:10 -07001352 const std::string &providerInstance,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001353 CameraProviderManager *manager) :
1354 mProviderName(providerName),
Emilian Peevc93cac22020-08-17 16:00:10 -07001355 mProviderInstance(providerInstance),
Emilian Peev71c73a22017-03-21 16:35:51 +00001356 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001357 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001358 mManager(manager) {
1359 (void) mManager;
1360}
1361
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001362status_t CameraProviderManager::ProviderInfo::initialize(
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001363 sp<provider::V2_4::ICameraProvider>& interface,
1364 hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001365 status_t res = parseProviderName(mProviderName, &mType, &mId);
1366 if (res != OK) {
1367 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1368 return BAD_VALUE;
1369 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001370 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001371 mProviderName.c_str(), interface->isRemote());
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001372
1373 // Determine minor version
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001374 mMinorVersion = 4;
1375 auto cast2_6 = provider::V2_6::ICameraProvider::castFrom(interface);
1376 sp<provider::V2_6::ICameraProvider> interface2_6 = nullptr;
1377 if (cast2_6.isOk()) {
1378 interface2_6 = cast2_6;
1379 if (interface2_6 != nullptr) {
1380 mMinorVersion = 6;
1381 }
1382 }
1383 // We need to check again since cast2_6.isOk() succeeds even if the provider
1384 // version isn't actually 2.6.
1385 if (interface2_6 == nullptr){
1386 auto cast2_5 =
1387 provider::V2_5::ICameraProvider::castFrom(interface);
1388 sp<provider::V2_5::ICameraProvider> interface2_5 = nullptr;
1389 if (cast2_5.isOk()) {
1390 interface2_5 = cast2_5;
1391 if (interface != nullptr) {
1392 mMinorVersion = 5;
1393 }
1394 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08001395 } else {
1396 auto cast2_7 = provider::V2_7::ICameraProvider::castFrom(interface);
1397 if (cast2_7.isOk()) {
1398 sp<provider::V2_7::ICameraProvider> interface2_7 = cast2_7;
1399 if (interface2_7 != nullptr) {
1400 mMinorVersion = 7;
1401 }
1402 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001403 }
1404
Shuzhen Wangbdf75f92020-07-10 14:13:33 -07001405 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1406 // before setCallback returns
1407 hardware::Return<Status> status = interface->setCallback(this);
1408 if (!status.isOk()) {
1409 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1410 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1411 return DEAD_OBJECT;
1412 }
1413 if (status != Status::OK) {
1414 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1415 __FUNCTION__, mProviderName.c_str());
1416 return mapToStatusT(status);
1417 }
1418
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001419 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001420 if (!linked.isOk()) {
1421 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1422 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1423 return DEAD_OBJECT;
1424 } else if (!linked) {
1425 ALOGW("%s: Unable to link to provider '%s' death notifications",
1426 __FUNCTION__, mProviderName.c_str());
1427 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001428
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001429 if (!kEnableLazyHal) {
1430 // Save HAL reference indefinitely
1431 mSavedInterface = interface;
1432 } else {
1433 mActiveInterface = interface;
1434 }
1435
1436 ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
1437 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1438 notifyDeviceStateChange(currentDeviceState);
1439
1440 res = setUpVendorTags();
1441 if (res != OK) {
1442 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1443 __FUNCTION__, mProviderName.c_str());
1444 return res;
1445 }
1446
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001447 // Get initial list of camera devices, if any
1448 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001449 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001450 Status idStatus,
1451 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1452 status = idStatus;
1453 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001454 for (auto& name : cameraDeviceNames) {
1455 uint16_t major, minor;
1456 std::string type, id;
1457 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1458 if (res != OK) {
1459 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1460 status = Status::INTERNAL_ERROR;
1461 } else {
1462 devices.push_back(name);
1463 mProviderPublicCameraIds.push_back(id);
1464 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001465 }
1466 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001467 if (!ret.isOk()) {
1468 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1469 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1470 return DEAD_OBJECT;
1471 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001472 if (status != Status::OK) {
1473 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1474 __FUNCTION__, mProviderName.c_str());
1475 return mapToStatusT(status);
1476 }
1477
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001478 // Get list of concurrent streaming camera device combinations
1479 if (mMinorVersion >= 6) {
Jayant Chowdharycad23c22020-03-10 15:04:59 -07001480 res = getConcurrentCameraIdsInternalLocked(interface2_6);
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001481 if (res != OK) {
1482 return res;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001483 }
1484 }
1485
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001486 ret = interface->isSetTorchModeSupported(
1487 [this](auto status, bool supported) {
1488 if (status == Status::OK) {
1489 mSetTorchModeSupported = supported;
1490 }
1491 });
1492 if (!ret.isOk()) {
1493 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1494 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1495 return DEAD_OBJECT;
1496 }
1497
1498 mIsRemote = interface->isRemote();
1499
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001500 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001501 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001502 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001503 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001504 if (res != OK) {
1505 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1506 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001507 continue;
1508 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001509 }
1510
1511 ALOGI("Camera provider %s ready with %zu camera devices",
1512 mProviderName.c_str(), mDevices.size());
1513
Shuzhen Wang394ad702020-07-23 13:01:54 -07001514 // Process cached status callbacks
1515 std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus =
1516 std::make_unique<std::vector<CameraStatusInfoT>>();
1517 {
1518 std::lock_guard<std::mutex> lock(mInitLock);
1519
1520 for (auto& statusInfo : mCachedStatus) {
1521 std::string id, physicalId;
1522 status_t res = OK;
1523 if (statusInfo.isPhysicalCameraStatus) {
1524 res = physicalCameraDeviceStatusChangeLocked(&id, &physicalId,
1525 statusInfo.cameraId, statusInfo.physicalCameraId, statusInfo.status);
1526 } else {
1527 res = cameraDeviceStatusChangeLocked(&id, statusInfo.cameraId, statusInfo.status);
1528 }
1529 if (res == OK) {
1530 cachedStatus->emplace_back(statusInfo.isPhysicalCameraStatus,
1531 id.c_str(), physicalId.c_str(), statusInfo.status);
1532 }
1533 }
1534 mCachedStatus.clear();
1535
1536 mInitialized = true;
1537 }
1538
1539 // The cached status change callbacks cannot be fired directly from this
1540 // function, due to same-thread deadlock trying to acquire mInterfaceMutex
1541 // twice.
1542 if (listener != nullptr) {
1543 mInitialStatusCallbackFuture = std::async(std::launch::async,
1544 &CameraProviderManager::ProviderInfo::notifyInitialStatusChange, this,
1545 listener, std::move(cachedStatus));
1546 }
1547
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001548 return OK;
1549}
1550
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001551const sp<provider::V2_4::ICameraProvider>
1552CameraProviderManager::ProviderInfo::startProviderInterface() {
1553 ATRACE_CALL();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001554 ALOGV("Request to start camera provider: %s", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001555 if (mSavedInterface != nullptr) {
1556 return mSavedInterface;
1557 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001558 if (!kEnableLazyHal) {
1559 ALOGE("Bad provider state! Should not be here on a non-lazy HAL!");
1560 return nullptr;
1561 }
1562
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001563 auto interface = mActiveInterface.promote();
1564 if (interface == nullptr) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001565 ALOGI("Camera HAL provider needs restart, calling getService(%s)", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001566 interface = mManager->mServiceProxy->getService(mProviderName);
1567 interface->setCallback(this);
1568 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
1569 if (!linked.isOk()) {
1570 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1571 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1572 mManager->removeProvider(mProviderName);
1573 return nullptr;
1574 } else if (!linked) {
1575 ALOGW("%s: Unable to link to provider '%s' death notifications",
1576 __FUNCTION__, mProviderName.c_str());
1577 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001578 // Send current device state
1579 if (mMinorVersion >= 5) {
1580 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1581 if (castResult.isOk()) {
1582 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1583 if (interface_2_5 != nullptr) {
1584 ALOGV("%s: Initial device state for %s: 0x %" PRIx64,
1585 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1586 interface_2_5->notifyDeviceStateChange(mDeviceState);
1587 }
1588 }
1589 }
1590
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001591 mActiveInterface = interface;
1592 } else {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001593 ALOGV("Camera provider (%s) already in use. Re-using instance.", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001594 }
1595 return interface;
1596}
1597
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001598const std::string& CameraProviderManager::ProviderInfo::getType() const {
1599 return mType;
1600}
1601
1602status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1603 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1604
1605 ALOGI("Enumerating new camera device: %s", name.c_str());
1606
1607 uint16_t major, minor;
1608 std::string type, id;
1609
1610 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1611 if (res != OK) {
1612 return res;
1613 }
1614 if (type != mType) {
1615 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1616 type.c_str(), mType.c_str());
1617 return BAD_VALUE;
1618 }
1619 if (mManager->isValidDeviceLocked(id, major)) {
1620 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1621 name.c_str(), id.c_str(), major);
1622 return BAD_VALUE;
1623 }
1624
1625 std::unique_ptr<DeviceInfo> deviceInfo;
1626 switch (major) {
1627 case 1:
Eino-Ville Talvalaa976df82019-06-13 18:01:58 -07001628 ALOGE("%s: Device %s: Unsupported HIDL device HAL major version %d:", __FUNCTION__,
1629 name.c_str(), major);
1630 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001631 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001632 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1633 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001634 break;
1635 default:
1636 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1637 name.c_str(), major);
1638 return BAD_VALUE;
1639 }
1640 if (deviceInfo == nullptr) return BAD_VALUE;
1641 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001642 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001643
1644 mDevices.push_back(std::move(deviceInfo));
1645
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001646 mUniqueCameraIds.insert(id);
1647 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001648 // addDevice can be called more than once for the same camera id if HAL
1649 // supports openLegacy.
1650 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1651 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1652 mUniqueAPI1CompatibleCameraIds.push_back(id);
1653 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001654 }
1655
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001656 if (parsedId != nullptr) {
1657 *parsedId = id;
1658 }
1659 return OK;
1660}
1661
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001662void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1663 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1664 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001665 mUniqueCameraIds.erase(id);
1666 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001667 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
1668 mUniqueAPI1CompatibleCameraIds.begin(),
1669 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001670 }
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001671 mDevices.erase(it);
1672 break;
1673 }
1674 }
1675}
1676
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001677status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001678 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
Emilian Peevc93cac22020-08-17 16:00:10 -07001679 mProviderInstance.c_str(),
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001680 mMinorVersion,
1681 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001682 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001683
1684 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001685 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1686 device->mVersion.get_major(), device->mVersion.get_minor());
1687 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1688 if (device->mResourceCost.conflictingDevices.size() == 0) {
1689 dprintf(fd, " Conflicting devices: None\n");
1690 } else {
1691 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001692 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001693 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001694 device->mResourceCost.conflictingDevices[i].c_str());
1695 }
1696 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001697 dprintf(fd, " API1 info:\n");
1698 dprintf(fd, " Has a flash unit: %s\n",
1699 device->hasFlashUnit() ? "true" : "false");
1700 hardware::CameraInfo info;
1701 status_t res = device->getCameraInfo(&info);
1702 if (res != OK) {
1703 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1704 strerror(-res), res);
1705 } else {
1706 dprintf(fd, " Facing: %s\n",
1707 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1708 dprintf(fd, " Orientation: %d\n", info.orientation);
1709 }
1710 CameraMetadata info2;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001711 res = device->getCameraCharacteristics(true /*overrideForPerfClass*/, &info2);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001712 if (res == INVALID_OPERATION) {
1713 dprintf(fd, " API2 not directly supported\n");
1714 } else if (res != OK) {
1715 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1716 strerror(-res), res);
1717 } else {
1718 dprintf(fd, " API2 camera characteristics:\n");
1719 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1720 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001721
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001722 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001723 if (device->mIsLogicalCamera) {
1724 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001725 // Skip if physical id is an independent camera
1726 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1727 != mProviderPublicCameraIds.end()) {
1728 continue;
1729 }
1730
1731 CameraMetadata physicalInfo;
1732 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1733 if (status == OK) {
1734 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1735 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1736 }
1737 }
1738 }
1739
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001740 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1741 device->mVersion.get_major(), device->mVersion.get_minor());
1742 res = device->dumpState(fd);
1743 if (res != OK) {
1744 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1745 device->mName.c_str(), strerror(-res), res);
1746 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001747 }
1748 return OK;
1749}
1750
Jayant Chowdharycad23c22020-03-10 15:04:59 -07001751status_t CameraProviderManager::ProviderInfo::getConcurrentCameraIdsInternalLocked(
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001752 sp<provider::V2_6::ICameraProvider> &interface2_6) {
1753 if (interface2_6 == nullptr) {
1754 ALOGE("%s: null interface provided", __FUNCTION__);
1755 return BAD_VALUE;
1756 }
1757 Status status = Status::OK;
1758 hardware::Return<void> ret =
1759 interface2_6->getConcurrentStreamingCameraIds([&status, this](
1760 Status concurrentIdStatus, // TODO: Move all instances of hidl_string to 'using'
1761 const hardware::hidl_vec<hardware::hidl_vec<hardware::hidl_string>>&
1762 cameraDeviceIdCombinations) {
1763 status = concurrentIdStatus;
1764 if (status == Status::OK) {
1765 mConcurrentCameraIdCombinations.clear();
1766 for (auto& combination : cameraDeviceIdCombinations) {
1767 std::unordered_set<std::string> deviceIds;
1768 for (auto &cameraDeviceId : combination) {
1769 deviceIds.insert(cameraDeviceId.c_str());
1770 }
1771 mConcurrentCameraIdCombinations.push_back(std::move(deviceIds));
1772 }
1773 } });
1774 if (!ret.isOk()) {
1775 ALOGE("%s: Transaction error in getting concurrent camera ID list from provider '%s'",
1776 __FUNCTION__, mProviderName.c_str());
1777 return DEAD_OBJECT;
1778 }
1779 if (status != Status::OK) {
1780 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1781 __FUNCTION__, mProviderName.c_str());
1782 return mapToStatusT(status);
1783 }
1784 return OK;
1785}
1786
1787status_t CameraProviderManager::ProviderInfo::reCacheConcurrentStreamingCameraIdsLocked() {
1788 if (mMinorVersion < 6) {
1789 // Unsupported operation, nothing to do here
1790 return OK;
1791 }
1792 // Check if the provider is currently active - not going to start it up for this notification
1793 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
1794 if (interface == nullptr) {
1795 ALOGE("%s: camera provider interface for %s is not valid", __FUNCTION__,
1796 mProviderName.c_str());
1797 return INVALID_OPERATION;
1798 }
1799 auto castResult = provider::V2_6::ICameraProvider::castFrom(interface);
1800
1801 if (castResult.isOk()) {
1802 sp<provider::V2_6::ICameraProvider> interface2_6 = castResult;
1803 if (interface2_6 != nullptr) {
Jayant Chowdharycad23c22020-03-10 15:04:59 -07001804 return getConcurrentCameraIdsInternalLocked(interface2_6);
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001805 } else {
1806 // This should not happen since mMinorVersion >= 6
1807 ALOGE("%s: mMinorVersion was >= 6, but interface2_6 was nullptr", __FUNCTION__);
1808 return UNKNOWN_ERROR;
1809 }
1810 }
1811 return OK;
1812}
1813
1814std::vector<std::unordered_set<std::string>>
1815CameraProviderManager::ProviderInfo::getConcurrentCameraIdCombinations() {
1816 std::lock_guard<std::mutex> lock(mLock);
1817 return mConcurrentCameraIdCombinations;
1818}
1819
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001820hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1821 const hardware::hidl_string& cameraDeviceName,
1822 CameraDeviceStatus newStatus) {
1823 sp<StatusListener> listener;
1824 std::string id;
Shuzhen Wang394ad702020-07-23 13:01:54 -07001825 std::lock_guard<std::mutex> lock(mInitLock);
1826
1827 if (!mInitialized) {
1828 mCachedStatus.emplace_back(false /*isPhysicalCameraStatus*/,
1829 cameraDeviceName.c_str(), std::string().c_str(), newStatus);
1830 return hardware::Void();
1831 }
1832
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001833 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001834 std::lock_guard<std::mutex> lock(mLock);
Shuzhen Wang394ad702020-07-23 13:01:54 -07001835 if (OK != cameraDeviceStatusChangeLocked(&id, cameraDeviceName, newStatus)) {
1836 return hardware::Void();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001837 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001838 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001839 }
Shuzhen Wang394ad702020-07-23 13:01:54 -07001840
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001841 // Call without lock held to allow reentrancy into provider manager
Shuzhen Wang394ad702020-07-23 13:01:54 -07001842 if (listener != nullptr) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001843 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
1844 }
Shuzhen Wang394ad702020-07-23 13:01:54 -07001845
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001846 return hardware::Void();
1847}
1848
Shuzhen Wang394ad702020-07-23 13:01:54 -07001849status_t CameraProviderManager::ProviderInfo::cameraDeviceStatusChangeLocked(
1850 std::string* id, const hardware::hidl_string& cameraDeviceName,
1851 CameraDeviceStatus newStatus) {
1852 bool known = false;
1853 std::string cameraId;
1854 for (auto& deviceInfo : mDevices) {
1855 if (deviceInfo->mName == cameraDeviceName) {
1856 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
1857 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
1858 deviceInfo->mStatus = newStatus;
1859 // TODO: Handle device removal (NOT_PRESENT)
1860 cameraId = deviceInfo->mId;
1861 known = true;
1862 break;
1863 }
1864 }
1865 // Previously unseen device; status must not be NOT_PRESENT
1866 if (!known) {
1867 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1868 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
1869 mProviderName.c_str(), cameraDeviceName.c_str());
1870 return BAD_VALUE;
1871 }
1872 addDevice(cameraDeviceName, newStatus, &cameraId);
1873 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1874 removeDevice(cameraId);
1875 }
1876 if (reCacheConcurrentStreamingCameraIdsLocked() != OK) {
1877 ALOGE("%s: CameraProvider %s could not re-cache concurrent streaming camera id list ",
1878 __FUNCTION__, mProviderName.c_str());
1879 }
1880 *id = cameraId;
1881 return OK;
1882}
1883
Shuzhen Wang43858162020-01-10 13:42:15 -08001884hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChange(
1885 const hardware::hidl_string& cameraDeviceName,
1886 const hardware::hidl_string& physicalCameraDeviceName,
1887 CameraDeviceStatus newStatus) {
1888 sp<StatusListener> listener;
1889 std::string id;
Shuzhen Wang394ad702020-07-23 13:01:54 -07001890 std::string physicalId;
1891 std::lock_guard<std::mutex> lock(mInitLock);
1892
1893 if (!mInitialized) {
1894 mCachedStatus.emplace_back(true /*isPhysicalCameraStatus*/, cameraDeviceName,
1895 physicalCameraDeviceName, newStatus);
1896 return hardware::Void();
1897 }
1898
Shuzhen Wang43858162020-01-10 13:42:15 -08001899 {
1900 std::lock_guard<std::mutex> lock(mLock);
Shuzhen Wangbdf75f92020-07-10 14:13:33 -07001901
Shuzhen Wang394ad702020-07-23 13:01:54 -07001902 if (OK != physicalCameraDeviceStatusChangeLocked(&id, &physicalId, cameraDeviceName,
1903 physicalCameraDeviceName, newStatus)) {
Shuzhen Wang43858162020-01-10 13:42:15 -08001904 return hardware::Void();
1905 }
Shuzhen Wang394ad702020-07-23 13:01:54 -07001906
Shuzhen Wang43858162020-01-10 13:42:15 -08001907 listener = mManager->getStatusListener();
Shuzhen Wang43858162020-01-10 13:42:15 -08001908 }
1909 // Call without lock held to allow reentrancy into provider manager
Shuzhen Wangbdf75f92020-07-10 14:13:33 -07001910 if (listener != nullptr) {
Shuzhen Wang43858162020-01-10 13:42:15 -08001911 listener->onDeviceStatusChanged(String8(id.c_str()),
Shuzhen Wang394ad702020-07-23 13:01:54 -07001912 String8(physicalId.c_str()), newStatus);
Shuzhen Wang43858162020-01-10 13:42:15 -08001913 }
1914 return hardware::Void();
1915}
1916
Shuzhen Wang394ad702020-07-23 13:01:54 -07001917status_t CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChangeLocked(
1918 std::string* id, std::string* physicalId,
1919 const hardware::hidl_string& cameraDeviceName,
1920 const hardware::hidl_string& physicalCameraDeviceName,
1921 CameraDeviceStatus newStatus) {
1922 bool known = false;
1923 std::string cameraId;
1924 for (auto& deviceInfo : mDevices) {
1925 if (deviceInfo->mName == cameraDeviceName) {
1926 cameraId = deviceInfo->mId;
1927 if (!deviceInfo->mIsLogicalCamera) {
1928 ALOGE("%s: Invalid combination of camera id %s, physical id %s",
1929 __FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
1930 return BAD_VALUE;
1931 }
1932 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1933 physicalCameraDeviceName) == deviceInfo->mPhysicalIds.end()) {
1934 ALOGE("%s: Invalid combination of camera id %s, physical id %s",
1935 __FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
1936 return BAD_VALUE;
1937 }
1938 ALOGI("Camera device %s physical device %s status is now %s",
1939 cameraDeviceName.c_str(), physicalCameraDeviceName.c_str(),
1940 deviceStatusToString(newStatus));
1941 known = true;
1942 break;
1943 }
1944 }
1945 // Previously unseen device; status must not be NOT_PRESENT
1946 if (!known) {
1947 ALOGW("Camera provider %s says an unknown camera device %s-%s is not present. Curious.",
1948 mProviderName.c_str(), cameraDeviceName.c_str(),
1949 physicalCameraDeviceName.c_str());
1950 return BAD_VALUE;
1951 }
1952
1953 *id = cameraId;
1954 *physicalId = physicalCameraDeviceName.c_str();
1955 return OK;
1956}
1957
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001958hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
1959 const hardware::hidl_string& cameraDeviceName,
1960 TorchModeStatus newStatus) {
1961 sp<StatusListener> listener;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001962 SystemCameraKind systemCameraKind = SystemCameraKind::PUBLIC;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001963 std::string id;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001964 bool known = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001965 {
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001966 // Hold mLock for accessing mDevices
1967 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001968 for (auto& deviceInfo : mDevices) {
1969 if (deviceInfo->mName == cameraDeviceName) {
1970 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
1971 torchStatusToString(newStatus));
1972 id = deviceInfo->mId;
1973 known = true;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001974 systemCameraKind = deviceInfo->mSystemCameraKind;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001975 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
1976 mManager->removeRef(DeviceMode::TORCH, id);
1977 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001978 break;
1979 }
1980 }
1981 if (!known) {
1982 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
1983 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
1984 return hardware::Void();
1985 }
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001986 // no lock needed since listener is set up only once during
1987 // CameraProviderManager initialization and then never changed till it is
1988 // destructed.
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001989 listener = mManager->getStatusListener();
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001990 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001991 // Call without lock held to allow reentrancy into provider manager
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001992 // The problem with holding mLock here is that we
1993 // might be limiting re-entrancy : CameraService::onTorchStatusChanged calls
1994 // back into CameraProviderManager which might try to hold mLock again (eg:
1995 // findDeviceInfo, which should be holding mLock while iterating through
1996 // each provider's devices).
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001997 if (listener != nullptr) {
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07001998 listener->onTorchStatusChanged(String8(id.c_str()), newStatus, systemCameraKind);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001999 }
2000 return hardware::Void();
2001}
2002
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002003void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
2004 const wp<hidl::base::V1_0::IBase>& who) {
2005 (void) who;
Emilian Peevc93cac22020-08-17 16:00:10 -07002006 ALOGI("Camera provider '%s' has died; removing it", mProviderInstance.c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002007 if (cookie != mId) {
2008 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
2009 __FUNCTION__, cookie, mId);
2010 }
Emilian Peevc93cac22020-08-17 16:00:10 -07002011 mManager->removeProvider(mProviderInstance);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002012}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002013
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08002014status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
2015 if (mVendorTagDescriptor != nullptr)
2016 return OK;
2017
2018 hardware::hidl_vec<VendorTagSection> vts;
2019 Status status;
2020 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002021 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
2022 if (interface == nullptr) {
2023 return DEAD_OBJECT;
2024 }
2025 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08002026 [&](auto s, const auto& vendorTagSecs) {
2027 status = s;
2028 if (s == Status::OK) {
2029 vts = vendorTagSecs;
2030 }
2031 });
2032 if (!ret.isOk()) {
2033 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
2034 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
2035 return DEAD_OBJECT;
2036 }
2037 if (status != Status::OK) {
2038 return mapToStatusT(status);
2039 }
2040
2041 // Read all vendor tag definitions into a descriptor
2042 status_t res;
2043 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
2044 != OK) {
2045 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
2046 "received error %s (%d). Camera clients will not be able to use"
2047 "vendor tags", __FUNCTION__, strerror(res), res);
2048 return res;
2049 }
2050
2051 return OK;
2052}
2053
Emilian Peevb50402e2021-09-24 17:41:57 -07002054void CameraProviderManager::ProviderInfo::notifyDeviceInfoStateChangeLocked(
2055 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
2056 std::lock_guard<std::mutex> lock(mLock);
2057 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
2058 (*it)->notifyDeviceStateChange(newDeviceState);
2059 }
2060}
2061
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08002062status_t CameraProviderManager::ProviderInfo::notifyDeviceStateChange(
2063 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
2064 mDeviceState = newDeviceState;
2065 if (mMinorVersion >= 5) {
2066 // Check if the provider is currently active - not going to start it up for this notification
2067 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
2068 if (interface != nullptr) {
2069 // Send current device state
2070 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
2071 if (castResult.isOk()) {
2072 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
2073 if (interface_2_5 != nullptr) {
2074 interface_2_5->notifyDeviceStateChange(mDeviceState);
2075 }
2076 }
2077 }
2078 }
2079 return OK;
2080}
2081
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002082status_t CameraProviderManager::ProviderInfo::isConcurrentSessionConfigurationSupported(
2083 const hardware::hidl_vec<CameraIdAndStreamCombination> &halCameraIdsAndStreamCombinations,
2084 bool *isSupported) {
2085 status_t res = OK;
2086 if (mMinorVersion >= 6) {
2087 // Check if the provider is currently active - not going to start it up for this notification
2088 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
2089 if (interface == nullptr) {
2090 // TODO: This might be some other problem
2091 return INVALID_OPERATION;
2092 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002093 auto castResult2_6 = provider::V2_6::ICameraProvider::castFrom(interface);
2094 auto castResult2_7 = provider::V2_7::ICameraProvider::castFrom(interface);
2095 Status callStatus;
2096 auto cb =
2097 [&isSupported, &callStatus](Status s, bool supported) {
2098 callStatus = s;
2099 *isSupported = supported; };
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002100
Shuzhen Wang83bff122020-11-20 15:51:39 -08002101 ::android::hardware::Return<void> ret;
2102 sp<provider::V2_7::ICameraProvider> interface_2_7;
2103 sp<provider::V2_6::ICameraProvider> interface_2_6;
2104 if (mMinorVersion >= 7 && castResult2_7.isOk()) {
2105 interface_2_7 = castResult2_7;
2106 if (interface_2_7 != nullptr) {
2107 ret = interface_2_7->isConcurrentStreamCombinationSupported_2_7(
2108 halCameraIdsAndStreamCombinations, cb);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002109 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002110 } else if (mMinorVersion == 6 && castResult2_6.isOk()) {
2111 interface_2_6 = castResult2_6;
2112 if (interface_2_6 != nullptr) {
2113 hardware::hidl_vec<provider::V2_6::CameraIdAndStreamCombination>
2114 halCameraIdsAndStreamCombinations_2_6;
2115 size_t numStreams = halCameraIdsAndStreamCombinations.size();
2116 halCameraIdsAndStreamCombinations_2_6.resize(numStreams);
2117 for (size_t i = 0; i < numStreams; i++) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002118 using namespace camera3;
Shuzhen Wang83bff122020-11-20 15:51:39 -08002119 auto const& combination = halCameraIdsAndStreamCombinations[i];
2120 halCameraIdsAndStreamCombinations_2_6[i].cameraId = combination.cameraId;
2121 bool success =
2122 SessionConfigurationUtils::convertHALStreamCombinationFromV37ToV34(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002123 halCameraIdsAndStreamCombinations_2_6[i].streamConfiguration,
2124 combination.streamConfiguration);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002125 if (!success) {
2126 *isSupported = false;
2127 return OK;
2128 }
2129 }
2130 ret = interface_2_6->isConcurrentStreamCombinationSupported(
2131 halCameraIdsAndStreamCombinations_2_6, cb);
2132 }
2133 }
2134
2135 if (interface_2_7 != nullptr || interface_2_6 != nullptr) {
2136 if (ret.isOk()) {
2137 switch (callStatus) {
2138 case Status::OK:
2139 // Expected case, do nothing.
2140 res = OK;
2141 break;
2142 case Status::METHOD_NOT_SUPPORTED:
2143 res = INVALID_OPERATION;
2144 break;
2145 default:
2146 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__,
2147 callStatus);
2148 res = UNKNOWN_ERROR;
2149 }
2150 } else {
2151 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2152 res = UNKNOWN_ERROR;
2153 }
2154 return res;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002155 }
2156 }
2157 // unsupported operation
2158 return INVALID_OPERATION;
2159}
2160
Shuzhen Wang394ad702020-07-23 13:01:54 -07002161void CameraProviderManager::ProviderInfo::notifyInitialStatusChange(
2162 sp<StatusListener> listener,
2163 std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus) {
2164 for (auto& statusInfo : *cachedStatus) {
2165 if (statusInfo.isPhysicalCameraStatus) {
2166 listener->onDeviceStatusChanged(String8(statusInfo.cameraId.c_str()),
2167 String8(statusInfo.physicalCameraId.c_str()), statusInfo.status);
2168 } else {
2169 listener->onDeviceStatusChanged(
2170 String8(statusInfo.cameraId.c_str()), statusInfo.status);
2171 }
2172 }
2173}
2174
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002175template<class DeviceInfoT>
2176std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
2177 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00002178 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002179 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002180 Status status;
2181
2182 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002183 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002184 if (cameraInterface == nullptr) return nullptr;
2185
2186 CameraResourceCost resourceCost;
2187 cameraInterface->getResourceCost([&status, &resourceCost](
2188 Status s, CameraResourceCost cost) {
2189 status = s;
2190 resourceCost = cost;
2191 });
2192 if (status != Status::OK) {
2193 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
2194 name.c_str(), statusToString(status));
2195 return nullptr;
2196 }
Shuzhen Wang47283692018-04-24 18:05:02 -07002197
2198 for (auto& conflictName : resourceCost.conflictingDevices) {
2199 uint16_t major, minor;
2200 std::string type, id;
2201 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
2202 if (res != OK) {
2203 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
2204 return nullptr;
2205 }
2206 conflictName = id;
2207 }
2208
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002209 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002210 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002211 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002212}
2213
2214template<class InterfaceT>
2215sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002216CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002217 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
2218 name.c_str(), InterfaceT::version.get_major());
2219 return nullptr;
2220}
2221
2222template<>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002223sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002224CameraProviderManager::ProviderInfo::startDeviceInterface
2225 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002226 Status status;
2227 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002228 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002229 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
2230 if (interface == nullptr) {
2231 return nullptr;
2232 }
2233 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002234 Status s, sp<device::V3_2::ICameraDevice> interface) {
2235 status = s;
2236 cameraInterface = interface;
2237 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002238 if (!ret.isOk()) {
2239 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
2240 __FUNCTION__, name.c_str(), ret.description().c_str());
2241 return nullptr;
2242 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002243 if (status != Status::OK) {
2244 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
2245 name.c_str(), statusToString(status));
2246 return nullptr;
2247 }
2248 return cameraInterface;
2249}
2250
2251CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
2252
2253template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002254sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
2255 sp<InterfaceT> device;
2256 ATRACE_CALL();
2257 if (mSavedInterface == nullptr) {
Shuzhen Wang79680432020-03-05 11:53:46 -08002258 sp<ProviderInfo> parentProvider = mParentProvider.promote();
2259 if (parentProvider != nullptr) {
2260 device = parentProvider->startDeviceInterface<InterfaceT>(mName);
2261 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002262 } else {
2263 device = (InterfaceT *) mSavedInterface.get();
2264 }
2265 return device;
2266}
2267
2268template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002269status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
2270 bool enabled) {
2271 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
2272 return mapToStatusT(s);
2273}
2274
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002275CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00002276 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002277 uint16_t minorVersion,
2278 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002279 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002280 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002281 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00002282 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002283 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002284 // Get camera characteristics and initialize flash unit availability
2285 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002286 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002287 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002288 device::V3_2::CameraMetadata metadata) {
2289 status = s;
2290 if (s == Status::OK) {
2291 camera_metadata_t *buffer =
2292 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07002293 size_t expectedSize = metadata.size();
2294 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2295 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2296 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2297 mCameraCharacteristics = buffer;
2298 } else {
2299 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2300 status = Status::INTERNAL_ERROR;
2301 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002302 }
2303 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002304 if (!ret.isOk()) {
2305 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002306 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002307 ret.description().c_str());
2308 return;
2309 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002310 if (status != Status::OK) {
2311 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002312 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002313 return;
2314 }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002315
Emilian Peevb50402e2021-09-24 17:41:57 -07002316 if (mCameraCharacteristics.exists(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS)) {
2317 const auto &stateMap = mCameraCharacteristics.find(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS);
2318 if ((stateMap.count > 0) && ((stateMap.count % 2) == 0)) {
2319 for (size_t i = 0; i < stateMap.count; i += 2) {
2320 mDeviceStateOrientationMap.emplace(stateMap.data.i64[i], stateMap.data.i64[i+1]);
2321 }
2322 } else {
2323 ALOGW("%s: Invalid ANDROID_INFO_DEVICE_STATE_ORIENTATIONS map size: %zu", __FUNCTION__,
2324 stateMap.count);
2325 }
2326 }
2327
Jayant Chowdhary5216b212019-07-17 09:26:23 -07002328 mSystemCameraKind = getSystemCameraKind();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002329
Shuzhen Wang268a1362018-10-16 16:32:59 -07002330 status_t res = fixupMonochromeTags();
2331 if (OK != res) {
2332 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
2333 __FUNCTION__, strerror(-res), res);
2334 return;
2335 }
Emilian Peeva1185162019-01-30 16:41:43 -08002336 auto stat = addDynamicDepthTags();
2337 if (OK != stat) {
2338 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-stat),
2339 stat);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00002340 }
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08002341 res = deriveHeicTags();
2342 if (OK != res) {
2343 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities: %s (%d)",
2344 __FUNCTION__, strerror(-res), res);
2345 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002346
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002347 if (SessionConfigurationUtils::isUltraHighResolutionSensor(mCameraCharacteristics)) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002348 status_t status = addDynamicDepthTags(/*maxResolution*/true);
2349 if (OK != status) {
2350 ALOGE("%s: Failed appending dynamic depth tags for maximum resolution mode: %s (%d)",
2351 __FUNCTION__, strerror(-status), status);
2352 }
2353
2354 status = deriveHeicTags(/*maxResolution*/true);
2355 if (OK != status) {
2356 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities for"
2357 "maximum resolution mode: %s (%d)", __FUNCTION__, strerror(-status), status);
2358 }
2359 }
2360
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08002361 res = addRotateCropTags();
2362 if (OK != res) {
2363 ALOGE("%s: Unable to add default SCALER_ROTATE_AND_CROP tags: %s (%d)", __FUNCTION__,
2364 strerror(-res), res);
2365 }
Shuzhen Wang9bf8a6f2020-05-01 09:49:04 -07002366 res = addPreCorrectionActiveArraySize();
2367 if (OK != res) {
2368 ALOGE("%s: Unable to add PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s (%d)", __FUNCTION__,
2369 strerror(-res), res);
2370 }
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08002371 res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
2372 &mCameraCharacteristics, &mSupportNativeZoomRatio);
2373 if (OK != res) {
2374 ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
2375 __FUNCTION__, strerror(-res), res);
2376 }
2377
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002378 camera_metadata_entry flashAvailable =
2379 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
2380 if (flashAvailable.count == 1 &&
2381 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
2382 mHasFlashUnit = true;
2383 } else {
2384 mHasFlashUnit = false;
2385 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002386
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002387 queryPhysicalCameraIds();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002388
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002389 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002390 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002391 if (!castResult.isOk()) {
2392 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
2393 return;
2394 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002395 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002396 if (interface_3_5 == nullptr) {
2397 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
2398 return;
2399 }
2400
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002401 if (mIsLogicalCamera) {
2402 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002403 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
2404 mPublicCameraIds.end()) {
2405 continue;
2406 }
2407
2408 hardware::hidl_string hidlId(id);
2409 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
2410 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
2411 status = s;
2412 if (s == Status::OK) {
2413 camera_metadata_t *buffer =
2414 reinterpret_cast<camera_metadata_t*>(metadata.data());
2415 size_t expectedSize = metadata.size();
2416 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2417 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2418 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2419 mPhysicalCameraCharacteristics[id] = buffer;
2420 } else {
2421 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2422 status = Status::INTERNAL_ERROR;
2423 }
2424 }
2425 });
2426
2427 if (!ret.isOk()) {
2428 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002429 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002430 return;
2431 }
2432 if (status != Status::OK) {
2433 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
2434 __FUNCTION__, id.c_str(), mId.c_str(),
2435 CameraProviderManager::statusToString(status), status);
2436 return;
2437 }
Shuzhen Wang1c834da2019-12-18 11:17:03 -08002438
2439 res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
2440 &mPhysicalCameraCharacteristics[id], &mSupportNativeZoomRatio);
2441 if (OK != res) {
2442 ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
2443 __FUNCTION__, strerror(-res), res);
2444 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002445 }
2446 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002447
2448 if (!kEnableLazyHal) {
2449 // Save HAL reference indefinitely
2450 mSavedInterface = interface;
2451 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002452}
2453
2454CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
2455
Emilian Peevb50402e2021-09-24 17:41:57 -07002456void CameraProviderManager::ProviderInfo::DeviceInfo3::notifyDeviceStateChange(
2457 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> newState) {
2458
2459 if (!mDeviceStateOrientationMap.empty() &&
2460 (mDeviceStateOrientationMap.find(newState) != mDeviceStateOrientationMap.end())) {
2461 mCameraCharacteristics.update(ANDROID_SENSOR_ORIENTATION,
2462 &mDeviceStateOrientationMap[newState], 1);
2463 }
2464}
2465
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002466status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002467 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002468}
2469
2470status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
2471 hardware::CameraInfo *info) const {
2472 if (info == nullptr) return BAD_VALUE;
2473
2474 camera_metadata_ro_entry facing =
2475 mCameraCharacteristics.find(ANDROID_LENS_FACING);
2476 if (facing.count == 1) {
2477 switch (facing.data.u8[0]) {
2478 case ANDROID_LENS_FACING_BACK:
2479 info->facing = hardware::CAMERA_FACING_BACK;
2480 break;
2481 case ANDROID_LENS_FACING_EXTERNAL:
2482 // Map external to front for legacy API
2483 case ANDROID_LENS_FACING_FRONT:
2484 info->facing = hardware::CAMERA_FACING_FRONT;
2485 break;
2486 }
2487 } else {
2488 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
2489 return NAME_NOT_FOUND;
2490 }
2491
2492 camera_metadata_ro_entry orientation =
2493 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
2494 if (orientation.count == 1) {
2495 info->orientation = orientation.data.i32[0];
2496 } else {
2497 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
2498 return NAME_NOT_FOUND;
2499 }
2500
2501 return OK;
2502}
Emilian Peevf53f66e2017-04-11 14:29:43 +01002503bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07002504 // Do not advertise NIR cameras to API1 camera app.
2505 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
2506 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
2507 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
2508 return false;
2509 }
2510
Emilian Peevf53f66e2017-04-11 14:29:43 +01002511 bool isBackwardCompatible = false;
2512 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
2513 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
2514 for (size_t i = 0; i < caps.count; i++) {
2515 if (caps.data.u8[i] ==
2516 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2517 isBackwardCompatible = true;
2518 break;
2519 }
2520 }
2521
2522 return isBackwardCompatible;
2523}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002524
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002525status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002526 native_handle_t* handle = native_handle_create(1,0);
2527 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002528 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
2529 if (interface == nullptr) {
2530 return DEAD_OBJECT;
2531 }
2532 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002533 native_handle_delete(handle);
2534 if (!ret.isOk()) {
2535 return INVALID_OPERATION;
2536 }
2537 return OK;
2538}
2539
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002540status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002541 bool overrideForPerfClass, CameraMetadata *characteristics) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002542 if (characteristics == nullptr) return BAD_VALUE;
2543
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002544 if (!overrideForPerfClass && mCameraCharNoPCOverride != nullptr) {
2545 *characteristics = *mCameraCharNoPCOverride;
2546 } else {
2547 *characteristics = mCameraCharacteristics;
2548 }
2549
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002550 return OK;
2551}
2552
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002553status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
2554 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
2555 if (characteristics == nullptr) return BAD_VALUE;
2556 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
2557 mPhysicalCameraCharacteristics.end()) {
2558 return NAME_NOT_FOUND;
2559 }
2560
2561 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
2562 return OK;
2563}
2564
Emilian Peev35ae8262018-11-08 13:11:32 +00002565status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
Shuzhen Wang83bff122020-11-20 15:51:39 -08002566 const hardware::camera::device::V3_7::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002567 bool *status /*out*/) {
2568
2569 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2570 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2571 if (interface == nullptr) {
2572 return DEAD_OBJECT;
2573 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002574 auto castResult_3_5 = device::V3_5::ICameraDevice::castFrom(interface);
2575 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult_3_5;
2576 auto castResult_3_7 = device::V3_7::ICameraDevice::castFrom(interface);
2577 sp<hardware::camera::device::V3_7::ICameraDevice> interface_3_7 = castResult_3_7;
Emilian Peev35ae8262018-11-08 13:11:32 +00002578
2579 status_t res;
2580 Status callStatus;
Shuzhen Wang83bff122020-11-20 15:51:39 -08002581 ::android::hardware::Return<void> ret;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002582 auto halCb =
Emilian Peev35ae8262018-11-08 13:11:32 +00002583 [&callStatus, &status] (Status s, bool combStatus) {
2584 callStatus = s;
2585 *status = combStatus;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002586 };
2587 if (interface_3_7 != nullptr) {
2588 ret = interface_3_7->isStreamCombinationSupported_3_7(configuration, halCb);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002589 } else if (interface_3_5 != nullptr) {
2590 hardware::camera::device::V3_4::StreamConfiguration configuration_3_4;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002591 bool success = SessionConfigurationUtils::convertHALStreamCombinationFromV37ToV34(
Shuzhen Wang83bff122020-11-20 15:51:39 -08002592 configuration_3_4, configuration);
2593 if (!success) {
2594 *status = false;
2595 return OK;
2596 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002597 ret = interface_3_5->isStreamCombinationSupported(configuration_3_4, halCb);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002598 } else {
2599 return INVALID_OPERATION;
2600 }
Emilian Peev35ae8262018-11-08 13:11:32 +00002601 if (ret.isOk()) {
2602 switch (callStatus) {
2603 case Status::OK:
2604 // Expected case, do nothing.
2605 res = OK;
2606 break;
2607 case Status::METHOD_NOT_SUPPORTED:
2608 res = INVALID_OPERATION;
2609 break;
2610 default:
2611 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
2612 res = UNKNOWN_ERROR;
2613 }
2614 } else {
2615 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2616 res = UNKNOWN_ERROR;
2617 }
2618
2619 return res;
2620}
2621
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002622status_t CameraProviderManager::ProviderInfo::DeviceInfo3::filterSmallJpegSizes() {
2623 int32_t thresholdW = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_W;
2624 int32_t thresholdH = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_H;
2625
2626 if (mCameraCharNoPCOverride != nullptr) return OK;
2627
2628 mCameraCharNoPCOverride = std::make_unique<CameraMetadata>(mCameraCharacteristics);
Shuzhen Wang89db2992021-05-20 13:09:48 -07002629
2630 // Remove small JPEG sizes from available stream configurations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002631 size_t largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002632 std::vector<int32_t> newStreamConfigs;
2633 camera_metadata_entry streamConfigs =
2634 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
2635 for (size_t i = 0; i < streamConfigs.count; i += 4) {
2636 if ((streamConfigs.data.i32[i] == HAL_PIXEL_FORMAT_BLOB) && (streamConfigs.data.i32[i+3] ==
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002637 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
2638 if (streamConfigs.data.i32[i+1] < thresholdW ||
2639 streamConfigs.data.i32[i+2] < thresholdH) {
2640 continue;
2641 } else {
2642 largeJpegCount ++;
2643 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002644 }
2645 newStreamConfigs.insert(newStreamConfigs.end(), streamConfigs.data.i32 + i,
2646 streamConfigs.data.i32 + i + 4);
2647 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002648 if (newStreamConfigs.size() == 0 || largeJpegCount == 0) {
2649 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002650 }
2651
2652 // Remove small JPEG sizes from available min frame durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002653 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002654 std::vector<int64_t> newMinDurations;
2655 camera_metadata_entry minDurations =
2656 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
2657 for (size_t i = 0; i < minDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002658 if (minDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
2659 if (minDurations.data.i64[i+1] < thresholdW ||
2660 minDurations.data.i64[i+2] < thresholdH) {
2661 continue;
2662 } else {
2663 largeJpegCount++;
2664 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002665 }
2666 newMinDurations.insert(newMinDurations.end(), minDurations.data.i64 + i,
2667 minDurations.data.i64 + i + 4);
2668 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002669 if (newMinDurations.size() == 0 || largeJpegCount == 0) {
2670 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002671 }
2672
2673 // Remove small JPEG sizes from available stall durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002674 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002675 std::vector<int64_t> newStallDurations;
2676 camera_metadata_entry stallDurations =
2677 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS);
2678 for (size_t i = 0; i < stallDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002679 if (stallDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
2680 if (stallDurations.data.i64[i+1] < thresholdW ||
2681 stallDurations.data.i64[i+2] < thresholdH) {
2682 continue;
2683 } else {
2684 largeJpegCount++;
2685 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002686 }
2687 newStallDurations.insert(newStallDurations.end(), stallDurations.data.i64 + i,
2688 stallDurations.data.i64 + i + 4);
2689 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002690 if (newStallDurations.size() == 0 || largeJpegCount == 0) {
2691 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002692 }
2693
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002694 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
2695 newStreamConfigs.data(), newStreamConfigs.size());
2696 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
2697 newMinDurations.data(), newMinDurations.size());
2698 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
2699 newStallDurations.data(), newStallDurations.size());
2700
Shuzhen Wang89db2992021-05-20 13:09:48 -07002701 // Re-generate metadata tags that have dependencies on BLOB sizes
2702 auto res = addDynamicDepthTags();
2703 if (OK != res) {
2704 ALOGE("%s: Failed to append dynamic depth tags: %s (%d)", __FUNCTION__,
2705 strerror(-res), res);
Shuzhen Wang2ebb8392021-06-21 23:31:10 -07002706 // Allow filtering of small JPEG sizes to succeed even if dynamic depth
2707 // tags fail to generate.
Shuzhen Wang89db2992021-05-20 13:09:48 -07002708 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002709
2710 return OK;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002711}
2712
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002713status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
2714 std::string *type, uint32_t *id) {
2715 // Format must be "<type>/<id>"
2716#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
2717 "Should match '<type>/<id>' - "
2718
2719 if (!type || !id) return INVALID_OPERATION;
2720
2721 std::string::size_type slashIdx = name.find('/');
2722 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
2723 ALOGE(ERROR_MSG_PREFIX
2724 "does not have / separator between type and id",
2725 __FUNCTION__, name.c_str());
2726 return BAD_VALUE;
2727 }
2728
2729 std::string typeVal = name.substr(0, slashIdx);
2730
2731 char *endPtr;
2732 errno = 0;
2733 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
2734 if (errno != 0) {
2735 ALOGE(ERROR_MSG_PREFIX
2736 "cannot parse provider id as an integer: %s (%d)",
2737 __FUNCTION__, name.c_str(), strerror(errno), errno);
2738 return BAD_VALUE;
2739 }
2740 if (endPtr != name.c_str() + name.size()) {
2741 ALOGE(ERROR_MSG_PREFIX
2742 "provider id has unexpected length",
2743 __FUNCTION__, name.c_str());
2744 return BAD_VALUE;
2745 }
2746 if (idVal < 0) {
2747 ALOGE(ERROR_MSG_PREFIX
2748 "id is negative: %ld",
2749 __FUNCTION__, name.c_str(), idVal);
2750 return BAD_VALUE;
2751 }
2752
2753#undef ERROR_MSG_PREFIX
2754
2755 *type = typeVal;
2756 *id = static_cast<uint32_t>(idVal);
2757
2758 return OK;
2759}
2760
Emilian Peev71c73a22017-03-21 16:35:51 +00002761metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
2762 const std::string &name) {
2763 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
2764 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
2765 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
2766 ret = 0;
2767 }
2768
2769 return ret;
2770}
2771
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002772status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
2773 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
2774
2775 // Format must be "device@<major>.<minor>/<type>/<id>"
2776
2777#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
2778 "Should match 'device@<major>.<minor>/<type>/<id>' - "
2779
2780 if (!major || !minor || !type || !id) return INVALID_OPERATION;
2781
2782 // Verify starting prefix
2783 const char expectedPrefix[] = "device@";
2784
2785 if (name.find(expectedPrefix) != 0) {
2786 ALOGE(ERROR_MSG_PREFIX
2787 "does not start with '%s'",
2788 __FUNCTION__, name.c_str(), expectedPrefix);
2789 return BAD_VALUE;
2790 }
2791
2792 // Extract major/minor versions
2793 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
2794 std::string::size_type dotIdx = name.find('.', atIdx);
2795 if (dotIdx == std::string::npos) {
2796 ALOGE(ERROR_MSG_PREFIX
2797 "does not have @<major>. version section",
2798 __FUNCTION__, name.c_str());
2799 return BAD_VALUE;
2800 }
2801 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
2802 if (typeSlashIdx == std::string::npos) {
2803 ALOGE(ERROR_MSG_PREFIX
2804 "does not have .<minor>/ version section",
2805 __FUNCTION__, name.c_str());
2806 return BAD_VALUE;
2807 }
2808
2809 char *endPtr;
2810 errno = 0;
2811 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
2812 if (errno != 0) {
2813 ALOGE(ERROR_MSG_PREFIX
2814 "cannot parse major version: %s (%d)",
2815 __FUNCTION__, name.c_str(), strerror(errno), errno);
2816 return BAD_VALUE;
2817 }
2818 if (endPtr != name.c_str() + dotIdx) {
2819 ALOGE(ERROR_MSG_PREFIX
2820 "major version has unexpected length",
2821 __FUNCTION__, name.c_str());
2822 return BAD_VALUE;
2823 }
2824 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
2825 if (errno != 0) {
2826 ALOGE(ERROR_MSG_PREFIX
2827 "cannot parse minor version: %s (%d)",
2828 __FUNCTION__, name.c_str(), strerror(errno), errno);
2829 return BAD_VALUE;
2830 }
2831 if (endPtr != name.c_str() + typeSlashIdx) {
2832 ALOGE(ERROR_MSG_PREFIX
2833 "minor version has unexpected length",
2834 __FUNCTION__, name.c_str());
2835 return BAD_VALUE;
2836 }
2837 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
2838 ALOGE(ERROR_MSG_PREFIX
2839 "major/minor version is out of range of uint16_t: %ld.%ld",
2840 __FUNCTION__, name.c_str(), majorVal, minorVal);
2841 return BAD_VALUE;
2842 }
2843
2844 // Extract type and id
2845
2846 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
2847 if (instanceSlashIdx == std::string::npos) {
2848 ALOGE(ERROR_MSG_PREFIX
2849 "does not have /<type>/ component",
2850 __FUNCTION__, name.c_str());
2851 return BAD_VALUE;
2852 }
2853 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
2854
2855 if (instanceSlashIdx == name.size() - 1) {
2856 ALOGE(ERROR_MSG_PREFIX
2857 "does not have an /<id> component",
2858 __FUNCTION__, name.c_str());
2859 return BAD_VALUE;
2860 }
2861 std::string idVal = name.substr(instanceSlashIdx + 1);
2862
2863#undef ERROR_MSG_PREFIX
2864
2865 *major = static_cast<uint16_t>(majorVal);
2866 *minor = static_cast<uint16_t>(minorVal);
2867 *type = typeVal;
2868 *id = idVal;
2869
2870 return OK;
2871}
2872
2873
2874
2875CameraProviderManager::ProviderInfo::~ProviderInfo() {
Shuzhen Wang394ad702020-07-23 13:01:54 -07002876 if (mInitialStatusCallbackFuture.valid()) {
2877 mInitialStatusCallbackFuture.wait();
2878 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002879 // Destruction of ProviderInfo is only supposed to happen when the respective
2880 // CameraProvider interface dies, so do not unregister callbacks.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002881}
2882
2883status_t CameraProviderManager::mapToStatusT(const Status& s) {
2884 switch(s) {
2885 case Status::OK:
2886 return OK;
2887 case Status::ILLEGAL_ARGUMENT:
2888 return BAD_VALUE;
2889 case Status::CAMERA_IN_USE:
2890 return -EBUSY;
2891 case Status::MAX_CAMERAS_IN_USE:
2892 return -EUSERS;
2893 case Status::METHOD_NOT_SUPPORTED:
2894 return UNKNOWN_TRANSACTION;
2895 case Status::OPERATION_NOT_SUPPORTED:
2896 return INVALID_OPERATION;
2897 case Status::CAMERA_DISCONNECTED:
2898 return DEAD_OBJECT;
2899 case Status::INTERNAL_ERROR:
2900 return INVALID_OPERATION;
2901 }
2902 ALOGW("Unexpected HAL status code %d", s);
2903 return INVALID_OPERATION;
2904}
2905
2906const char* CameraProviderManager::statusToString(const Status& s) {
2907 switch(s) {
2908 case Status::OK:
2909 return "OK";
2910 case Status::ILLEGAL_ARGUMENT:
2911 return "ILLEGAL_ARGUMENT";
2912 case Status::CAMERA_IN_USE:
2913 return "CAMERA_IN_USE";
2914 case Status::MAX_CAMERAS_IN_USE:
2915 return "MAX_CAMERAS_IN_USE";
2916 case Status::METHOD_NOT_SUPPORTED:
2917 return "METHOD_NOT_SUPPORTED";
2918 case Status::OPERATION_NOT_SUPPORTED:
2919 return "OPERATION_NOT_SUPPORTED";
2920 case Status::CAMERA_DISCONNECTED:
2921 return "CAMERA_DISCONNECTED";
2922 case Status::INTERNAL_ERROR:
2923 return "INTERNAL_ERROR";
2924 }
2925 ALOGW("Unexpected HAL status code %d", s);
2926 return "UNKNOWN_ERROR";
2927}
2928
2929const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
2930 switch(s) {
2931 case CameraDeviceStatus::NOT_PRESENT:
2932 return "NOT_PRESENT";
2933 case CameraDeviceStatus::PRESENT:
2934 return "PRESENT";
2935 case CameraDeviceStatus::ENUMERATING:
2936 return "ENUMERATING";
2937 }
2938 ALOGW("Unexpected HAL device status code %d", s);
2939 return "UNKNOWN_STATUS";
2940}
2941
2942const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
2943 switch(s) {
2944 case TorchModeStatus::NOT_AVAILABLE:
2945 return "NOT_AVAILABLE";
2946 case TorchModeStatus::AVAILABLE_OFF:
2947 return "AVAILABLE_OFF";
2948 case TorchModeStatus::AVAILABLE_ON:
2949 return "AVAILABLE_ON";
2950 }
2951 ALOGW("Unexpected HAL torch mode status code %d", s);
2952 return "UNKNOWN_STATUS";
2953}
2954
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002955
2956status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002957 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002958 /*out*/
2959 sp<VendorTagDescriptor>& descriptor) {
2960
2961 int tagCount = 0;
2962
2963 for (size_t s = 0; s < vts.size(); s++) {
2964 tagCount += vts[s].tags.size();
2965 }
2966
2967 if (tagCount < 0 || tagCount > INT32_MAX) {
2968 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
2969 return BAD_VALUE;
2970 }
2971
2972 Vector<uint32_t> tagArray;
2973 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
2974 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
2975
2976
2977 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
2978 desc->mTagCount = tagCount;
2979
2980 SortedVector<String8> sections;
2981 KeyedVector<uint32_t, String8> tagToSectionMap;
2982
2983 int idx = 0;
2984 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002985 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002986 const char *sectionName = section.sectionName.c_str();
2987 if (sectionName == NULL) {
2988 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
2989 return BAD_VALUE;
2990 }
2991 String8 sectionString(sectionName);
2992 sections.add(sectionString);
2993
2994 for (size_t j = 0; j < section.tags.size(); j++) {
2995 uint32_t tag = section.tags[j].tagId;
2996 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
2997 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
2998 return BAD_VALUE;
2999 }
3000
3001 tagArray.editItemAt(idx++) = section.tags[j].tagId;
3002
3003 const char *tagName = section.tags[j].tagName.c_str();
3004 if (tagName == NULL) {
3005 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
3006 return BAD_VALUE;
3007 }
3008 desc->mTagToNameMap.add(tag, String8(tagName));
3009 tagToSectionMap.add(tag, sectionString);
3010
3011 int tagType = (int) section.tags[j].tagType;
3012 if (tagType < 0 || tagType >= NUM_TYPES) {
3013 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
3014 return BAD_VALUE;
3015 }
3016 desc->mTagToTypeMap.add(tag, tagType);
3017 }
3018 }
3019
3020 desc->mSections = sections;
3021
3022 for (size_t i = 0; i < tagArray.size(); ++i) {
3023 uint32_t tag = tagArray[i];
3024 String8 sectionString = tagToSectionMap.valueFor(tag);
3025
3026 // Set up tag to section index map
3027 ssize_t index = sections.indexOf(sectionString);
3028 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
3029 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
3030
3031 // Set up reverse mapping
3032 ssize_t reverseIndex = -1;
3033 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
3034 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
3035 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
3036 }
3037 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
3038 }
3039
George Burgess IVa0b84962017-08-29 17:46:19 -07003040 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003041 return OK;
3042}
3043
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003044// Expects to have mInterfaceMutex locked
3045std::vector<std::unordered_set<std::string>>
Jayant Chowdharycad23c22020-03-10 15:04:59 -07003046CameraProviderManager::getConcurrentCameraIds() const {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003047 std::vector<std::unordered_set<std::string>> deviceIdCombinations;
3048 std::lock_guard<std::mutex> lock(mInterfaceMutex);
3049 for (auto &provider : mProviders) {
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08003050 for (auto &combinations : provider->getConcurrentCameraIdCombinations()) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003051 deviceIdCombinations.push_back(combinations);
3052 }
3053 }
3054 return deviceIdCombinations;
3055}
3056
3057status_t CameraProviderManager::convertToHALStreamCombinationAndCameraIdsLocked(
3058 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003059 const std::set<std::string>& perfClassPrimaryCameraIds,
3060 int targetSdkVersion,
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003061 hardware::hidl_vec<CameraIdAndStreamCombination> *halCameraIdsAndStreamCombinations,
3062 bool *earlyExit) {
3063 binder::Status bStatus = binder::Status::ok();
3064 std::vector<CameraIdAndStreamCombination> halCameraIdsAndStreamsV;
3065 bool shouldExit = false;
3066 status_t res = OK;
3067 for (auto &cameraIdAndSessionConfig : cameraIdsAndSessionConfigs) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003068 const std::string& cameraId = cameraIdAndSessionConfig.mCameraId;
Shuzhen Wang83bff122020-11-20 15:51:39 -08003069 hardware::camera::device::V3_7::StreamConfiguration streamConfiguration;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003070 CameraMetadata deviceInfo;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003071 bool overrideForPerfClass =
3072 SessionConfigurationUtils::targetPerfClassPrimaryCamera(
3073 perfClassPrimaryCameraIds, cameraId, targetSdkVersion);
3074 res = getCameraCharacteristicsLocked(cameraId, overrideForPerfClass, &deviceInfo);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003075 if (res != OK) {
3076 return res;
3077 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08003078 camera3::metadataGetter getMetadata =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003079 [this](const String8 &id, bool overrideForPerfClass) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003080 CameraMetadata physicalDeviceInfo;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003081 getCameraCharacteristicsLocked(id.string(), overrideForPerfClass,
3082 &physicalDeviceInfo);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003083 return physicalDeviceInfo;
3084 };
3085 std::vector<std::string> physicalCameraIds;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003086 isLogicalCameraLocked(cameraId, &physicalCameraIds);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003087 bStatus =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003088 SessionConfigurationUtils::convertToHALStreamCombination(
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003089 cameraIdAndSessionConfig.mSessionConfiguration,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003090 String8(cameraId.c_str()), deviceInfo, getMetadata,
3091 physicalCameraIds, streamConfiguration,
3092 overrideForPerfClass, &shouldExit);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003093 if (!bStatus.isOk()) {
3094 ALOGE("%s: convertToHALStreamCombination failed", __FUNCTION__);
3095 return INVALID_OPERATION;
3096 }
3097 if (shouldExit) {
3098 *earlyExit = true;
3099 return OK;
3100 }
3101 CameraIdAndStreamCombination halCameraIdAndStream;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003102 halCameraIdAndStream.cameraId = cameraId;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003103 halCameraIdAndStream.streamConfiguration = streamConfiguration;
3104 halCameraIdsAndStreamsV.push_back(halCameraIdAndStream);
3105 }
3106 *halCameraIdsAndStreamCombinations = halCameraIdsAndStreamsV;
3107 return OK;
3108}
3109
3110// Checks if the containing vector of sets has any set that contains all of the
3111// camera ids in cameraIdsAndSessionConfigs.
3112static bool checkIfSetContainsAll(
3113 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
3114 const std::vector<std::unordered_set<std::string>> &containingSets) {
3115 for (auto &containingSet : containingSets) {
3116 bool didHaveAll = true;
3117 for (auto &cameraIdAndSessionConfig : cameraIdsAndSessionConfigs) {
3118 if (containingSet.find(cameraIdAndSessionConfig.mCameraId) == containingSet.end()) {
3119 // a camera id doesn't belong to this set, keep looking in other
3120 // sets
3121 didHaveAll = false;
3122 break;
3123 }
3124 }
3125 if (didHaveAll) {
3126 // found a set that has all camera ids, lets return;
3127 return true;
3128 }
3129 }
3130 return false;
3131}
3132
3133status_t CameraProviderManager::isConcurrentSessionConfigurationSupported(
3134 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003135 const std::set<std::string>& perfClassPrimaryCameraIds,
3136 int targetSdkVersion, bool *isSupported) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003137 std::lock_guard<std::mutex> lock(mInterfaceMutex);
3138 // Check if all the devices are a subset of devices advertised by the
3139 // same provider through getConcurrentStreamingCameraIds()
3140 // TODO: we should also do a findDeviceInfoLocked here ?
3141 for (auto &provider : mProviders) {
3142 if (checkIfSetContainsAll(cameraIdsAndSessionConfigs,
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08003143 provider->getConcurrentCameraIdCombinations())) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003144 // For each camera device in cameraIdsAndSessionConfigs collect
3145 // the streamConfigs and create the HAL
3146 // CameraIdAndStreamCombination, exit early if needed
3147 hardware::hidl_vec<CameraIdAndStreamCombination> halCameraIdsAndStreamCombinations;
3148 bool knowUnsupported = false;
3149 status_t res = convertToHALStreamCombinationAndCameraIdsLocked(
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003150 cameraIdsAndSessionConfigs, perfClassPrimaryCameraIds,
3151 targetSdkVersion, &halCameraIdsAndStreamCombinations, &knowUnsupported);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003152 if (res != OK) {
3153 ALOGE("%s unable to convert session configurations provided to HAL stream"
3154 "combinations", __FUNCTION__);
3155 return res;
3156 }
3157 if (knowUnsupported) {
3158 // We got to know the streams aren't valid before doing the HAL
3159 // call itself.
3160 *isSupported = false;
3161 return OK;
3162 }
3163 return provider->isConcurrentSessionConfigurationSupported(
3164 halCameraIdsAndStreamCombinations, isSupported);
3165 }
3166 }
3167 *isSupported = false;
3168 //The set of camera devices were not found
3169 return INVALID_OPERATION;
3170}
3171
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003172status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003173 bool overrideForPerfClass, CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003174 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
3175 if (deviceInfo != nullptr) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003176 return deviceInfo->getCameraCharacteristics(overrideForPerfClass, characteristics);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003177 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003178
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003179 // Find hidden physical camera characteristics
3180 for (auto& provider : mProviders) {
3181 for (auto& deviceInfo : provider->mDevices) {
3182 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
3183 if (res != NAME_NOT_FOUND) return res;
3184 }
3185 }
3186
3187 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003188}
3189
3190void CameraProviderManager::filterLogicalCameraIdsLocked(
3191 std::vector<std::string>& deviceIds) const
3192{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003193 // Map between camera facing and camera IDs related to logical camera.
3194 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003195
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003196 // Collect all logical and its underlying physical camera IDs for each
3197 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003198 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07003199 auto deviceInfo = findDeviceInfoLocked(deviceId);
3200 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003201
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07003202 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003203 continue;
3204 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003205
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003206 // combo contains the ids of a logical camera and its physical cameras
3207 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
3208 combo.push_back(deviceId);
3209
3210 hardware::CameraInfo info;
3211 status_t res = deviceInfo->getCameraInfo(&info);
3212 if (res != OK) {
3213 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
3214 continue;
3215 }
3216 idCombos[info.facing].insert(combo.begin(), combo.end());
3217 }
3218
3219 // Only expose one camera ID per facing for all logical and underlying
3220 // physical camera IDs.
3221 for (auto& r : idCombos) {
3222 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003223 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003224 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
3225 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003226 continue;
3227 }
3228
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003229 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003230 break;
3231 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003232 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
3233 [&removedIds](const std::string& s) {
3234 return removedIds.find(s) != removedIds.end();}),
3235 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003236 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003237}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003238
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003239} // namespace android