blob: 98313281fc0e88a168c0320e108e19f4a4972402 [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
Rucha Katakwar38284522021-11-10 11:25:21 -080023#include <android/hardware/camera/device/3.8/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;
Austin Borgerea931242021-12-13 23:10:41 +000049using namespace ::android::camera3;
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));
Valentin Iftime29e2e152021-08-13 15:17:33 +020056const std::string kExternalProviderName = "external/0";
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080057} // anonymous namespace
58
Emilian Peev538c90e2018-12-17 18:03:19 +000059const float CameraProviderManager::kDepthARTolerance = .1f;
60
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080061CameraProviderManager::HardwareServiceInteractionProxy
62CameraProviderManager::sHardwareServiceInteractionProxy{};
63
64CameraProviderManager::~CameraProviderManager() {
65}
66
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070067hardware::hidl_vec<hardware::hidl_string>
68CameraProviderManager::HardwareServiceInteractionProxy::listServices() {
69 hardware::hidl_vec<hardware::hidl_string> ret;
70 auto manager = hardware::defaultServiceManager1_2();
71 if (manager != nullptr) {
72 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
73 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
74 ret = registered;
75 });
76 }
77 return ret;
78}
79
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080080status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
81 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080082 std::lock_guard<std::mutex> lock(mInterfaceMutex);
83 if (proxy == nullptr) {
84 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
85 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080086 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080087 mListener = listener;
88 mServiceProxy = proxy;
Eino-Ville Talvala63f36112018-12-06 14:57:03 -080089 mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
90 provider::V2_5::DeviceState::NORMAL);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080091
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080092 // Registering will trigger notifications for all already-known providers
93 bool success = mServiceProxy->registerForNotifications(
94 /* instance name, empty means no filter */ "",
95 this);
96 if (!success) {
97 ALOGE("%s: Unable to register with hardware service manager for notifications "
98 "about camera providers", __FUNCTION__);
99 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -0800100 }
Emilian Peev5d7e5152017-02-22 15:37:48 +0000101
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -0700102
103 for (const auto& instance : mServiceProxy->listServices()) {
104 this->addProviderLocked(instance);
105 }
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800106
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700107 IPCThreadState::self()->flushCommands();
108
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800109 return OK;
110}
111
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700112std::pair<int, int> CameraProviderManager::getCameraCount() const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800113 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700114 int systemCameraCount = 0;
115 int publicCameraCount = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800116 for (auto& provider : mProviders) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700117 for (auto &id : provider->mUniqueCameraIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700118 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
119 if (getSystemCameraKindLocked(id, &deviceKind) != OK) {
120 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, id.c_str());
121 continue;
122 }
123 switch(deviceKind) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700124 case SystemCameraKind::PUBLIC:
125 publicCameraCount++;
126 break;
127 case SystemCameraKind::SYSTEM_ONLY_CAMERA:
128 systemCameraCount++;
129 break;
130 default:
131 break;
132 }
133 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800134 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700135 return std::make_pair(systemCameraCount, publicCameraCount);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800136}
137
138std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
139 std::lock_guard<std::mutex> lock(mInterfaceMutex);
140 std::vector<std::string> deviceIds;
141 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700142 for (auto& id : provider->mUniqueCameraIds) {
143 deviceIds.push_back(id);
144 }
145 }
146 return deviceIds;
147}
148
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700149void CameraProviderManager::collectDeviceIdsLocked(const std::vector<std::string> deviceIds,
150 std::vector<std::string>& publicDeviceIds,
151 std::vector<std::string>& systemDeviceIds) const {
152 for (auto &deviceId : deviceIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700153 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
154 if (getSystemCameraKindLocked(deviceId, &deviceKind) != OK) {
155 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, deviceId.c_str());
156 continue;
157 }
158 if (deviceKind == SystemCameraKind::SYSTEM_ONLY_CAMERA) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700159 systemDeviceIds.push_back(deviceId);
160 } else {
161 publicDeviceIds.push_back(deviceId);
162 }
163 }
164}
165
Emilian Peevf53f66e2017-04-11 14:29:43 +0100166std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700167 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700168 std::vector<std::string> publicDeviceIds;
169 std::vector<std::string> systemDeviceIds;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700170 std::vector<std::string> deviceIds;
171 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700172 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700173 // Secure cameras should not be exposed through camera 1 api
174 providerDeviceIds.erase(std::remove_if(providerDeviceIds.begin(), providerDeviceIds.end(),
175 [this](const std::string& s) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700176 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
177 if (getSystemCameraKindLocked(s, &deviceKind) != OK) {
178 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, s.c_str());
179 return true;
180 }
181 return deviceKind == SystemCameraKind::HIDDEN_SECURE_CAMERA;}),
182 providerDeviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700183 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700184 // for each camera facing, only take the first id advertised by HAL in
185 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700186 filterLogicalCameraIdsLocked(providerDeviceIds);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700187 collectDeviceIdsLocked(providerDeviceIds, publicDeviceIds, systemDeviceIds);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800188 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700189 auto sortFunc =
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800190 [](const std::string& a, const std::string& b) -> bool {
191 uint32_t aUint = 0, bUint = 0;
192 bool aIsUint = base::ParseUint(a, &aUint);
193 bool bIsUint = base::ParseUint(b, &bUint);
194
195 // Uint device IDs first
196 if (aIsUint && bIsUint) {
197 return aUint < bUint;
198 } else if (aIsUint) {
199 return true;
200 } else if (bIsUint) {
201 return false;
202 }
203 // Simple string compare if both id are not uint
204 return a < b;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700205 };
206 // We put device ids for system cameras at the end since they will be pared
207 // off for processes not having system camera permissions.
208 std::sort(publicDeviceIds.begin(), publicDeviceIds.end(), sortFunc);
209 std::sort(systemDeviceIds.begin(), systemDeviceIds.end(), sortFunc);
210 deviceIds.insert(deviceIds.end(), publicDeviceIds.begin(), publicDeviceIds.end());
211 deviceIds.insert(deviceIds.end(), systemDeviceIds.begin(), systemDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800212 return deviceIds;
213}
214
215bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
216 std::lock_guard<std::mutex> lock(mInterfaceMutex);
217 return isValidDeviceLocked(id, majorVersion);
218}
219
220bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
221 for (auto& provider : mProviders) {
222 for (auto& deviceInfo : provider->mDevices) {
223 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
224 return true;
225 }
226 }
227 }
228 return false;
229}
230
231bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
232 std::lock_guard<std::mutex> lock(mInterfaceMutex);
233
234 auto deviceInfo = findDeviceInfoLocked(id);
235 if (deviceInfo == nullptr) return false;
236
237 return deviceInfo->hasFlashUnit();
238}
239
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800240bool CameraProviderManager::supportNativeZoomRatio(const std::string &id) const {
241 std::lock_guard<std::mutex> lock(mInterfaceMutex);
242
243 auto deviceInfo = findDeviceInfoLocked(id);
244 if (deviceInfo == nullptr) return false;
245
246 return deviceInfo->supportNativeZoomRatio();
247}
248
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800249status_t CameraProviderManager::getResourceCost(const std::string &id,
250 CameraResourceCost* cost) const {
251 std::lock_guard<std::mutex> lock(mInterfaceMutex);
252
253 auto deviceInfo = findDeviceInfoLocked(id);
254 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
255
256 *cost = deviceInfo->mResourceCost;
257 return OK;
258}
259
260status_t CameraProviderManager::getCameraInfo(const std::string &id,
261 hardware::CameraInfo* info) const {
262 std::lock_guard<std::mutex> lock(mInterfaceMutex);
263
264 auto deviceInfo = findDeviceInfoLocked(id);
265 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
266
267 return deviceInfo->getCameraInfo(info);
268}
269
Emilian Peev35ae8262018-11-08 13:11:32 +0000270status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
Emilian Peev2295df72021-11-12 18:14:10 -0800271 const hardware::camera::device::V3_8::StreamConfiguration &configuration,
Emilian Peev35ae8262018-11-08 13:11:32 +0000272 bool *status /*out*/) const {
273 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Emilian Peev35ae8262018-11-08 13:11:32 +0000274 auto deviceInfo = findDeviceInfoLocked(id);
275 if (deviceInfo == nullptr) {
276 return NAME_NOT_FOUND;
277 }
278
279 return deviceInfo->isSessionConfigurationSupported(configuration, status);
280}
281
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800282status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700283 bool overrideForPerfClass, CameraMetadata* characteristics) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800284 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700285 return getCameraCharacteristicsLocked(id, overrideForPerfClass, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800286}
287
288status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
289 hardware::hidl_version *v) {
290 std::lock_guard<std::mutex> lock(mInterfaceMutex);
291
292 hardware::hidl_version maxVersion{0,0};
293 bool found = false;
294 for (auto& provider : mProviders) {
295 for (auto& deviceInfo : provider->mDevices) {
296 if (deviceInfo->mId == id) {
297 if (deviceInfo->mVersion > maxVersion) {
298 maxVersion = deviceInfo->mVersion;
299 found = true;
300 }
301 }
302 }
303 }
304 if (!found) {
305 return NAME_NOT_FOUND;
306 }
307 *v = maxVersion;
308 return OK;
309}
310
Rucha Katakwar38284522021-11-10 11:25:21 -0800311status_t CameraProviderManager::getTorchStrengthLevel(const std::string &id,
312 int32_t* torchStrength /*out*/) {
313 std::lock_guard<std::mutex> lock(mInterfaceMutex);
314
315 auto deviceInfo = findDeviceInfoLocked(id);
316 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
317
318 return deviceInfo->getTorchStrengthLevel(torchStrength);
319}
320
321status_t CameraProviderManager::turnOnTorchWithStrengthLevel(const std::string &id,
322 int32_t torchStrength) {
323 std::lock_guard<std::mutex> lock(mInterfaceMutex);
324
325 auto deviceInfo = findDeviceInfoLocked(id);
326 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
327
328 return deviceInfo->turnOnTorchWithStrengthLevel(torchStrength);
329}
330
331bool CameraProviderManager::shouldSkipTorchStrengthUpdate(const std::string &id,
332 int32_t torchStrength) const {
333 std::lock_guard<std::mutex> lock(mInterfaceMutex);
334
335 auto deviceInfo = findDeviceInfoLocked(id);
336 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
337
338 if (deviceInfo->mTorchStrengthLevel == torchStrength) {
339 ALOGV("%s: Skipping torch strength level updates prev_level: %d, new_level: %d",
340 __FUNCTION__, deviceInfo->mTorchStrengthLevel, torchStrength);
341 return true;
342 }
343 return false;
344}
345
346int32_t CameraProviderManager::getTorchDefaultStrengthLevel(const std::string &id) const {
347 std::lock_guard<std::mutex> lock(mInterfaceMutex);
348
349 auto deviceInfo = findDeviceInfoLocked(id);
350 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
351
352 return deviceInfo->mTorchDefaultStrengthLevel;
353}
354
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700355bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700356 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700357 for (auto& provider : mProviders) {
358 auto deviceInfo = findDeviceInfoLocked(id);
359 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700360 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700361 }
362 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700363 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700364}
365
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800366status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
367 std::lock_guard<std::mutex> lock(mInterfaceMutex);
368
369 auto deviceInfo = findDeviceInfoLocked(id);
370 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
371
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700372 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
373 // that are currently in use.
Shuzhen Wang79680432020-03-05 11:53:46 -0800374 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
375 if (parentProvider == nullptr) {
376 return DEAD_OBJECT;
377 }
378 const sp<provider::V2_4::ICameraProvider> interface = parentProvider->startProviderInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700379 if (interface == nullptr) {
380 return DEAD_OBJECT;
381 }
382 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
383
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800384 return deviceInfo->setTorchMode(enabled);
385}
386
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800387status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000388 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
389
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800390 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800391 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800392 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000393
394 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
395
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800396 return OK;
397}
398
Valentin Iftime29e2e152021-08-13 15:17:33 +0200399sp<CameraProviderManager::ProviderInfo> CameraProviderManager::startExternalLazyProvider() const {
400 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
401 std::lock_guard<std::mutex> lock(mInterfaceMutex);
402
403 for (const auto& providerInfo : mProviders) {
404 if (providerInfo->isExternalLazyHAL()) {
405 const sp<provider::V2_4::ICameraProvider>
406 interface = providerInfo->startProviderInterface();
407 if (interface == nullptr) {
408 return nullptr;
409 } else {
410 return providerInfo;
411 }
412 }
413 }
414 return nullptr;
415}
416
417status_t CameraProviderManager::notifyUsbDeviceEvent(int32_t eventId,
418 const std::string& usbDeviceId) {
419 if (!kEnableLazyHal) {
420 return OK;
421 }
422
423 ALOGV("notifySystemEvent: %d usbDeviceId : %s", eventId, usbDeviceId.c_str());
424
425 if (eventId == android::hardware::ICameraService::EVENT_USB_DEVICE_ATTACHED) {
426 sp<ProviderInfo> externalProvider = startExternalLazyProvider();
427 if (externalProvider != nullptr) {
428 auto usbDevices = mExternalUsbDevicesForProvider.first;
429 usbDevices.push_back(usbDeviceId);
430 mExternalUsbDevicesForProvider = {usbDevices, externalProvider};
431 }
432 } else if (eventId
433 == android::hardware::ICameraService::EVENT_USB_DEVICE_DETACHED) {
434 usbDeviceDetached(usbDeviceId);
435 }
436
437 return OK;
438}
439
440status_t CameraProviderManager::usbDeviceDetached(const std::string &usbDeviceId) {
441 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
442 std::lock_guard<std::mutex> interfaceLock(mInterfaceMutex);
443
444 auto usbDevices = mExternalUsbDevicesForProvider.first;
445 auto foundId = std::find(usbDevices.begin(), usbDevices.end(), usbDeviceId);
446 if (foundId != usbDevices.end()) {
447 sp<ProviderInfo> providerInfo = mExternalUsbDevicesForProvider.second;
448 if (providerInfo == nullptr) {
449 ALOGE("%s No valid external provider for USB device: %s",
450 __FUNCTION__,
451 usbDeviceId.c_str());
452 mExternalUsbDevicesForProvider = {std::vector<std::string>(), nullptr};
453 return DEAD_OBJECT;
454 } else {
455 mInterfaceMutex.unlock();
456 providerInfo->removeAllDevices();
457 mInterfaceMutex.lock();
458 mExternalUsbDevicesForProvider = {std::vector<std::string>(), nullptr};
459 }
460 } else {
461 return DEAD_OBJECT;
462 }
463 return OK;
464}
465
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800466status_t CameraProviderManager::notifyDeviceStateChange(
467 hardware::hidl_bitfield<provider::V2_5::DeviceState> newState) {
468 std::lock_guard<std::mutex> lock(mInterfaceMutex);
469 mDeviceState = newState;
470 status_t res = OK;
471 for (auto& provider : mProviders) {
472 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
473 __FUNCTION__, provider->mProviderName.c_str(), newState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700474 // b/199240726 Camera providers can for example try to add/remove
475 // camera devices as part of the state change notification. Holding
476 // 'mInterfaceMutex' while calling 'notifyDeviceStateChange' can
477 // result in a recursive deadlock.
478 mInterfaceMutex.unlock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800479 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700480 mInterfaceMutex.lock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800481 if (singleRes != OK) {
482 ALOGE("%s: Unable to notify provider %s about device state change",
483 __FUNCTION__,
484 provider->mProviderName.c_str());
485 res = singleRes;
486 // continue to do the rest of the providers instead of returning now
487 }
Emilian Peevb50402e2021-09-24 17:41:57 -0700488 provider->notifyDeviceInfoStateChangeLocked(mDeviceState);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800489 }
490 return res;
491}
492
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800493status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800494 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800495 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800496 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800497
498 std::lock_guard<std::mutex> lock(mInterfaceMutex);
499
500 auto deviceInfo = findDeviceInfoLocked(id,
501 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
502 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
503
504 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Shuzhen Wang79680432020-03-05 11:53:46 -0800505 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
506 if (parentProvider == nullptr) {
507 return DEAD_OBJECT;
508 }
509 const sp<provider::V2_4::ICameraProvider> provider = parentProvider->startProviderInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700510 if (provider == nullptr) {
511 return DEAD_OBJECT;
512 }
513 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800514
515 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700516 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700517 auto interface = deviceInfo3->startDeviceInterface<
518 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
519 if (interface == nullptr) {
520 return DEAD_OBJECT;
521 }
522
523 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800524 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
525 status = s;
526 if (status == Status::OK) {
527 *session = cameraSession;
528 }
529 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700530 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700531 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700532 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
533 __FUNCTION__, id.c_str(), ret.description().c_str());
534 return DEAD_OBJECT;
535 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800536 return mapToStatusT(status);
537}
538
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700539void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
540 sp<provider::V2_4::ICameraProvider> provider) {
541 if (!kEnableLazyHal) {
542 return;
543 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800544 ALOGV("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700545 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
546 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
547 if (usageType == DeviceMode::TORCH) {
548 primaryMap = &mTorchProviderByCameraId;
549 alternateMap = &mCameraProviderByCameraId;
550 } else {
551 primaryMap = &mCameraProviderByCameraId;
552 alternateMap = &mTorchProviderByCameraId;
553 }
554 auto id = cameraId.c_str();
555 (*primaryMap)[id] = provider;
556 auto search = alternateMap->find(id);
557 if (search != alternateMap->end()) {
558 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
559 "That should not be possible", __FUNCTION__, id);
560 }
561 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
562}
563
564void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
565 if (!kEnableLazyHal) {
566 return;
567 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800568 ALOGV("Removing camera device %s", cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700569 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
570 if (usageType == DeviceMode::TORCH) {
571 providerMap = &mTorchProviderByCameraId;
572 } else {
573 providerMap = &mCameraProviderByCameraId;
574 }
575 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
576 auto search = providerMap->find(cameraId.c_str());
577 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800578 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
579 // added delay) because hwservicemanager guarantees to hold the reference for at least five
580 // more seconds. We depend on this behavior so that if the provider is unreferenced and
581 // then referenced again quickly, we do not let the HAL exit and then need to immediately
582 // restart it. An example when this could happen is switching from a front-facing to a
583 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
584 // appear janky to the user.
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700585 providerMap->erase(cameraId.c_str());
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800586 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700587 } else {
588 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
589 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
590 cameraId.c_str());
591 }
592}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800593
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800594hardware::Return<void> CameraProviderManager::onRegistration(
595 const hardware::hidl_string& /*fqName*/,
596 const hardware::hidl_string& name,
Emilian Peevc93cac22020-08-17 16:00:10 -0700597 bool preexisting) {
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700598 status_t res = OK;
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700599 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100600 {
601 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800602
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700603 res = addProviderLocked(name, preexisting);
Emilian Peevaee727d2017-05-04 16:35:48 +0100604 }
605
606 sp<StatusListener> listener = getStatusListener();
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700607 if (nullptr != listener.get() && res == OK) {
Emilian Peevaee727d2017-05-04 16:35:48 +0100608 listener->onNewProviderRegistered();
609 }
610
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700611 IPCThreadState::self()->flushCommands();
612
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800613 return hardware::Return<void>();
614}
615
616status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
617 std::lock_guard<std::mutex> lock(mInterfaceMutex);
618
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800619 for (auto& provider : mProviders) {
620 provider->dump(fd, args);
621 }
622 return OK;
623}
624
625CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800626 const std::string& id,
627 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800628 for (auto& provider : mProviders) {
629 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800630 if (deviceInfo->mId == id &&
631 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800632 return deviceInfo.get();
633 }
634 }
635 }
636 return nullptr;
637}
638
Emilian Peev71c73a22017-03-21 16:35:51 +0000639metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
640 const std::string& id, hardware::hidl_version minVersion,
641 hardware::hidl_version maxVersion) const {
642 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
643
644 std::lock_guard<std::mutex> lock(mInterfaceMutex);
645 for (auto& provider : mProviders) {
646 for (auto& deviceInfo : provider->mDevices) {
647 if (deviceInfo->mId == id &&
648 minVersion <= deviceInfo->mVersion &&
649 maxVersion >= deviceInfo->mVersion) {
650 return provider->mProviderTagid;
651 }
652 }
653 }
654
655 return ret;
656}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800657
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700658void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
659 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700660
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700661 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700662 for (size_t i = 0; i < entryCap.count; ++i) {
663 uint8_t capability = entryCap.data.u8[i];
664 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700665 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700666 break;
667 }
668 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700669 if (!mIsLogicalCamera) {
670 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700671 }
672
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700673 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
674 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700675 const uint8_t* ids = entryIds.data.u8;
676 size_t start = 0;
677 for (size_t i = 0; i < entryIds.count; ++i) {
678 if (ids[i] == '\0') {
679 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700680 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700681 }
682 start = i+1;
683 }
684 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700685}
686
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700687SystemCameraKind CameraProviderManager::ProviderInfo::DeviceInfo3::getSystemCameraKind() {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800688 camera_metadata_entry_t entryCap;
689 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700690 if (entryCap.count == 1 &&
691 entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
692 return SystemCameraKind::HIDDEN_SECURE_CAMERA;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800693 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700694
695 // Go through the capabilities and check if it has
696 // ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA
697 for (size_t i = 0; i < entryCap.count; ++i) {
698 uint8_t capability = entryCap.data.u8[i];
699 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA) {
700 return SystemCameraKind::SYSTEM_ONLY_CAMERA;
701 }
702 }
703 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800704}
705
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000706void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
707 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
708 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
709 if (sizes == nullptr) {
710 return;
711 }
712
713 auto scalerDims = ch.find(tag);
714 if (scalerDims.count > 0) {
715 // Scaler entry contains 4 elements (format, width, height, type)
716 for (size_t i = 0; i < scalerDims.count; i += 4) {
717 if ((scalerDims.data.i32[i] == format) &&
718 (scalerDims.data.i32[i+3] ==
719 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
720 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
721 scalerDims.data.i32[i+2]));
722 }
723 }
724 }
725}
726
727void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
728 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
729 const std::vector<std::tuple<size_t, size_t>>& sizes,
730 std::vector<int64_t> *durations/*out*/) {
731 if (durations == nullptr) {
732 return;
733 }
734
735 auto availableDurations = ch.find(tag);
736 if (availableDurations.count > 0) {
737 // Duration entry contains 4 elements (format, width, height, duration)
738 for (size_t i = 0; i < availableDurations.count; i += 4) {
739 for (const auto& size : sizes) {
740 int64_t width = std::get<0>(size);
741 int64_t height = std::get<1>(size);
742 if ((availableDurations.data.i64[i] == format) &&
743 (availableDurations.data.i64[i+1] == width) &&
744 (availableDurations.data.i64[i+2] == height)) {
745 durations->push_back(availableDurations.data.i64[i+3]);
746 }
747 }
748 }
749 }
750}
751void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
752 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
753 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
754 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
755 return;
756 }
757
758 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
759 // Processing time on camera service side can vary greatly depending on multiple
760 // variables which are not under our control. Make a guesstimate by taking the maximum
761 // corresponding duration value from depth and blob.
762 auto depthDuration = depthDurations.begin();
763 auto blobDuration = blobDurations.begin();
764 dynamicDepthDurations->reserve(depthDurations.size());
765 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
766 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
767 depthDuration++; blobDuration++;
768 }
769}
770
771void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
772 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
773 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
774 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
775 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
776 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
777 return;
778 }
779
780 // The dynamic depth spec. does not mention how close the AR ratio should be.
781 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000782 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000783
784 for (const auto& blobSize : blobSizes) {
785 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
786 static_cast<float>(std::get<1>(blobSize));
787 bool found = false;
788 for (const auto& depthSize : depthSizes) {
789 if (depthSize == blobSize) {
790 internalDepthSizes->push_back(depthSize);
791 found = true;
792 break;
793 } else {
794 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
795 static_cast<float>(std::get<1>(depthSize));
796 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
797 internalDepthSizes->push_back(depthSize);
798 found = true;
799 break;
800 }
801 }
802 }
803
804 if (found) {
805 dynamicDepthSizes->push_back(blobSize);
806 }
807 }
808}
809
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800810status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags(
811 bool maxResolution) {
812 const int32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
813
814 const int32_t scalerSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700815 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800816 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
817 const int32_t scalerMinFrameDurationsTag =
818 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
819 const int32_t scalerStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700820 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800821 ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, maxResolution);
822
823 const int32_t depthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700824 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800825 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
826 const int32_t depthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700827 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800828 ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, maxResolution);
829 const int32_t depthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700830 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800831 ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
832
833 const int32_t dynamicDepthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700834 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800835 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
836 const int32_t dynamicDepthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700837 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800838 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS, maxResolution);
839 const int32_t dynamicDepthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700840 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800841 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
842
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000843 auto& c = mCameraCharacteristics;
844 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
845 supportedDynamicDepthSizes, internalDepthSizes;
846 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
847 if (chTags.count == 0) {
848 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
849 return BAD_VALUE;
850 }
851
852 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
853 depthExclTag) != (chTags.data.i32 + chTags.count);
854 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -0800855 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000856 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
857 // No depth support, nothing more to do.
858 return OK;
859 }
860
861 auto depthExclusiveEntry = c.find(depthExclTag);
862 if (depthExclusiveEntry.count > 0) {
863 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
864 // Depth support is exclusive, nothing more to do.
865 return OK;
866 }
867 } else {
868 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
869 return BAD_VALUE;
870 }
871
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800872 getSupportedSizes(c, scalerSizesTag, HAL_PIXEL_FORMAT_BLOB,
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000873 &supportedBlobSizes);
874 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
875 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
876 // Nothing to do in this case.
877 return OK;
878 }
879
880 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
881 &supportedDynamicDepthSizes, &internalDepthSizes);
882 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000883 // Nothing more to do.
884 return OK;
885 }
886
887 std::vector<int32_t> dynamicDepthEntries;
888 for (const auto& it : supportedDynamicDepthSizes) {
889 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
890 static_cast<int32_t> (std::get<1>(it)),
891 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
892 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
893 }
894
895 std::vector<int64_t> depthMinDurations, depthStallDurations;
896 std::vector<int64_t> blobMinDurations, blobStallDurations;
897 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
898
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800899 getSupportedDurations(c, depthMinFrameDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
900 &depthMinDurations);
901 getSupportedDurations(c, scalerMinFrameDurationsTag, HAL_PIXEL_FORMAT_BLOB,
902 supportedDynamicDepthSizes, &blobMinDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000903 if (blobMinDurations.empty() || depthMinDurations.empty() ||
904 (depthMinDurations.size() != blobMinDurations.size())) {
905 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
906 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
907 return BAD_VALUE;
908 }
909
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800910 getSupportedDurations(c, depthStallDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
911 &depthStallDurations);
912 getSupportedDurations(c, scalerStallDurationsTag, HAL_PIXEL_FORMAT_BLOB,
913 supportedDynamicDepthSizes, &blobStallDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000914 if (blobStallDurations.empty() || depthStallDurations.empty() ||
915 (depthStallDurations.size() != blobStallDurations.size())) {
916 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
917 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
918 return BAD_VALUE;
919 }
920
921 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
922 &dynamicDepthMinDurations);
923 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
924 &dynamicDepthStallDurations);
925 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
926 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
927 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
928 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
929 return BAD_VALUE;
930 }
931
932 std::vector<int64_t> dynamicDepthMinDurationEntries;
933 auto itDuration = dynamicDepthMinDurations.begin();
934 auto itSize = supportedDynamicDepthSizes.begin();
935 while (itDuration != dynamicDepthMinDurations.end()) {
936 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
937 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
938 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
939 entry + 4);
940 itDuration++; itSize++;
941 }
942
943 std::vector<int64_t> dynamicDepthStallDurationEntries;
944 itDuration = dynamicDepthStallDurations.begin();
945 itSize = supportedDynamicDepthSizes.begin();
946 while (itDuration != dynamicDepthStallDurations.end()) {
947 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
948 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
949 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
950 entry + 4);
951 itDuration++; itSize++;
952 }
953
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000954 std::vector<int32_t> supportedChTags;
955 supportedChTags.reserve(chTags.count + 3);
956 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
957 chTags.data.i32 + chTags.count);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800958 supportedChTags.push_back(dynamicDepthSizesTag);
959 supportedChTags.push_back(dynamicDepthMinFrameDurationsTag);
960 supportedChTags.push_back(dynamicDepthStallDurationsTag);
961 c.update(dynamicDepthSizesTag, dynamicDepthEntries.data(), dynamicDepthEntries.size());
962 c.update(dynamicDepthMinFrameDurationsTag, dynamicDepthMinDurationEntries.data(),
963 dynamicDepthMinDurationEntries.size());
964 c.update(dynamicDepthStallDurationsTag, dynamicDepthStallDurationEntries.data(),
965 dynamicDepthStallDurationEntries.size());
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000966 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
967 supportedChTags.size());
968
969 return OK;
970}
971
Shuzhen Wang268a1362018-10-16 16:32:59 -0700972status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
973 status_t res = OK;
974 auto& c = mCameraCharacteristics;
975
976 // Override static metadata for MONOCHROME camera with older device version
977 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
978 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
979 for (size_t i = 0; i < cap.count; i++) {
980 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
981 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
982 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
983 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
984 if (res != OK) {
985 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
986 __FUNCTION__, strerror(-res), res);
987 return res;
988 }
989
990 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
991 const std::vector<uint32_t> sKeys = {
992 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
993 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
994 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
995 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
996 ANDROID_SENSOR_COLOR_TRANSFORM1,
997 ANDROID_SENSOR_COLOR_TRANSFORM2,
998 ANDROID_SENSOR_FORWARD_MATRIX1,
999 ANDROID_SENSOR_FORWARD_MATRIX2,
1000 };
1001 res = removeAvailableKeys(c, sKeys,
1002 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1003 if (res != OK) {
1004 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
1005 __FUNCTION__, strerror(-res), res);
1006 return res;
1007 }
1008
1009 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
1010 const std::vector<uint32_t> reqKeys = {
1011 ANDROID_COLOR_CORRECTION_MODE,
1012 ANDROID_COLOR_CORRECTION_TRANSFORM,
1013 ANDROID_COLOR_CORRECTION_GAINS,
1014 };
1015 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
1016 if (res != OK) {
1017 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
1018 __FUNCTION__, strerror(-res), res);
1019 return res;
1020 }
1021
1022 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
1023 const std::vector<uint32_t> resKeys = {
1024 ANDROID_SENSOR_GREEN_SPLIT,
1025 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
1026 ANDROID_COLOR_CORRECTION_MODE,
1027 ANDROID_COLOR_CORRECTION_TRANSFORM,
1028 ANDROID_COLOR_CORRECTION_GAINS,
1029 };
1030 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
1031 if (res != OK) {
1032 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
1033 __FUNCTION__, strerror(-res), res);
1034 return res;
1035 }
1036
1037 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
1038 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
1039 for (size_t j = 1; j < blEntry.count; j++) {
1040 blEntry.data.i32[j] = blEntry.data.i32[0];
1041 }
1042 }
1043 }
1044 }
1045 return res;
1046}
1047
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001048status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addRotateCropTags() {
1049 status_t res = OK;
1050 auto& c = mCameraCharacteristics;
1051
1052 auto availableRotateCropEntry = c.find(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES);
1053 if (availableRotateCropEntry.count == 0) {
1054 uint8_t defaultAvailableRotateCropEntry = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
1055 res = c.update(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,
1056 &defaultAvailableRotateCropEntry, 1);
1057 }
1058 return res;
1059}
1060
Shuzhen Wang9bf8a6f2020-05-01 09:49:04 -07001061status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addPreCorrectionActiveArraySize() {
1062 status_t res = OK;
1063 auto& c = mCameraCharacteristics;
1064
1065 auto activeArraySize = c.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
1066 auto preCorrectionActiveArraySize = c.find(
1067 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
1068 if (activeArraySize.count == 4 && preCorrectionActiveArraySize.count == 0) {
1069 std::vector<int32_t> preCorrectionArray(
1070 activeArraySize.data.i32, activeArraySize.data.i32+4);
1071 res = c.update(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
1072 preCorrectionArray.data(), 4);
1073 if (res != OK) {
1074 ALOGE("%s: Failed to add ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s(%d)",
1075 __FUNCTION__, strerror(-res), res);
1076 return res;
1077 }
1078 } else {
1079 return res;
1080 }
1081
1082 auto charTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1083 bool hasPreCorrectionActiveArraySize = std::find(charTags.data.i32,
1084 charTags.data.i32 + charTags.count,
1085 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE) !=
1086 (charTags.data.i32 + charTags.count);
1087 if (!hasPreCorrectionActiveArraySize) {
1088 std::vector<int32_t> supportedCharTags;
1089 supportedCharTags.reserve(charTags.count + 1);
1090 supportedCharTags.insert(supportedCharTags.end(), charTags.data.i32,
1091 charTags.data.i32 + charTags.count);
1092 supportedCharTags.push_back(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
1093
1094 res = c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedCharTags.data(),
1095 supportedCharTags.size());
1096 if (res != OK) {
1097 ALOGE("%s: Failed to update ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s(%d)",
1098 __FUNCTION__, strerror(-res), res);
1099 return res;
1100 }
1101 }
1102
1103 return res;
1104}
1105
Shuzhen Wang268a1362018-10-16 16:32:59 -07001106status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
1107 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
1108 status_t res = OK;
1109
1110 camera_metadata_entry keysEntry = c.find(keyTag);
1111 if (keysEntry.count == 0) {
1112 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
1113 return res;
1114 }
1115 std::vector<int32_t> vKeys;
1116 vKeys.reserve(keysEntry.count);
1117 for (size_t i = 0; i < keysEntry.count; i++) {
1118 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
1119 vKeys.push_back(keysEntry.data.i32[i]);
1120 }
1121 }
1122 res = c.update(keyTag, vKeys.data(), vKeys.size());
1123 return res;
1124}
1125
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001126status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
1127 std::vector<int32_t>* outputs,
1128 std::vector<int64_t>* durations,
1129 std::vector<int64_t>* stallDurations,
1130 const camera_metadata_entry& halStreamConfigs,
1131 const camera_metadata_entry& halStreamDurations) {
1132 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
1133 return BAD_VALUE;
1134 }
1135
1136 static bool supportInMemoryTempFile =
1137 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
1138 if (!supportInMemoryTempFile) {
1139 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
1140 __FUNCTION__);
1141 return OK;
1142 }
1143
1144 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
1145 int32_t format = halStreamConfigs.data.i32[i];
1146 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
1147 // image.
1148 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
1149 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
1150 continue;
1151 }
1152
1153 bool sizeAvail = false;
1154 for (size_t j = 0; j < outputs->size(); j+= 4) {
1155 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
1156 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
1157 sizeAvail = true;
1158 break;
1159 }
1160 }
1161 if (sizeAvail) continue;
1162
1163 int64_t stall = 0;
Susmitha Gummallafca67142020-03-05 14:58:30 -08001164 bool useHeic = false;
1165 bool useGrid = false;
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001166 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
1167 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
1168 &useHeic, &useGrid, &stall)) {
1169 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
1170 continue;
1171 }
1172
1173 // HEIC configuration
1174 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1175 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
1176 outputs->insert(outputs->end(), config, config + 4);
1177
1178 // HEIC minFrameDuration
1179 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
1180 if (halStreamDurations.data.i64[j] == format &&
1181 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
1182 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
1183 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1184 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
1185 durations->insert(durations->end(), duration, duration+4);
1186 break;
1187 }
1188 }
1189
1190 // HEIC stallDuration
1191 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1192 halStreamConfigs.data.i32[i+2], stall};
1193 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
1194 }
1195 }
1196 return OK;
1197}
1198
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001199status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags(bool maxResolution) {
1200 int32_t scalerStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001201 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001202 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
1203 int32_t scalerMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001204 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001205 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, maxResolution);
1206
1207 int32_t heicStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001208 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001209 ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS, maxResolution);
1210 int32_t heicMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001211 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001212 ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS, maxResolution);
1213 int32_t heicStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001214 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001215 ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS, maxResolution);
1216
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001217 auto& c = mCameraCharacteristics;
1218
1219 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
1220 if (halHeicSupport.count > 1) {
1221 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
1222 __FUNCTION__, halHeicSupport.count);
1223 return BAD_VALUE;
1224 } else if (halHeicSupport.count == 0 ||
1225 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
1226 // Camera HAL doesn't support mandatory stream combinations for HEIC.
1227 return OK;
1228 }
1229
1230 camera_metadata_entry maxJpegAppsSegments =
1231 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1232 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1233 maxJpegAppsSegments.data.u8[0] > 16) {
1234 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1235 __FUNCTION__);
1236 return BAD_VALUE;
1237 }
1238
1239 // Populate HEIC output configurations and its related min frame duration
1240 // and stall duration.
1241 std::vector<int32_t> heicOutputs;
1242 std::vector<int64_t> heicDurations;
1243 std::vector<int64_t> heicStallDurations;
1244
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001245 camera_metadata_entry halStreamConfigs = c.find(scalerStreamSizesTag);
1246 camera_metadata_entry minFrameDurations = c.find(scalerMinFrameDurationsTag);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001247
1248 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
1249 halStreamConfigs, minFrameDurations);
1250 if (res != OK) {
1251 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
1252 strerror(-res), res);
1253 return res;
1254 }
1255
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001256 c.update(heicStreamSizesTag, heicOutputs.data(), heicOutputs.size());
1257 c.update(heicMinFrameDurationsTag, heicDurations.data(), heicDurations.size());
1258 c.update(heicStallDurationsTag, heicStallDurations.data(), heicStallDurations.size());
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001259
1260 return OK;
1261}
1262
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001263bool CameraProviderManager::isLogicalCameraLocked(const std::string& id,
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001264 std::vector<std::string>* physicalCameraIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001265 auto deviceInfo = findDeviceInfoLocked(id);
1266 if (deviceInfo == nullptr) return false;
1267
1268 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
1269 *physicalCameraIds = deviceInfo->mPhysicalIds;
1270 }
1271 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001272}
1273
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001274bool CameraProviderManager::isLogicalCamera(const std::string& id,
1275 std::vector<std::string>* physicalCameraIds) {
1276 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1277 return isLogicalCameraLocked(id, physicalCameraIds);
1278}
1279
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001280status_t CameraProviderManager::getSystemCameraKind(const std::string& id,
1281 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001282 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001283 return getSystemCameraKindLocked(id, kind);
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001284}
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001285
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001286status_t CameraProviderManager::getSystemCameraKindLocked(const std::string& id,
1287 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001288 auto deviceInfo = findDeviceInfoLocked(id);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001289 if (deviceInfo != nullptr) {
1290 *kind = deviceInfo->mSystemCameraKind;
1291 return OK;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001292 }
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001293 // If this is a hidden physical camera, we should return what kind of
1294 // camera the enclosing logical camera is.
1295 auto isHiddenAndParent = isHiddenPhysicalCameraInternal(id);
1296 if (isHiddenAndParent.first) {
1297 LOG_ALWAYS_FATAL_IF(id == isHiddenAndParent.second->mId,
1298 "%s: hidden physical camera id %s and enclosing logical camera id %s are the same",
1299 __FUNCTION__, id.c_str(), isHiddenAndParent.second->mId.c_str());
1300 return getSystemCameraKindLocked(isHiddenAndParent.second->mId, kind);
1301 }
1302 // Neither a hidden physical camera nor a logical camera
1303 return NAME_NOT_FOUND;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001304}
1305
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001306bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) const {
Emilian Peev7fe6c422021-09-08 13:43:20 -07001307 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001308 return isHiddenPhysicalCameraInternal(cameraId).first;
1309}
1310
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001311status_t CameraProviderManager::filterSmallJpegSizes(const std::string& cameraId) {
Emilian Peev7fe6c422021-09-08 13:43:20 -07001312 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wang89db2992021-05-20 13:09:48 -07001313 for (auto& provider : mProviders) {
1314 for (auto& deviceInfo : provider->mDevices) {
1315 if (deviceInfo->mId == cameraId) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001316 return deviceInfo->filterSmallJpegSizes();
Shuzhen Wang89db2992021-05-20 13:09:48 -07001317 }
1318 }
1319 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001320 return NAME_NOT_FOUND;
Shuzhen Wang89db2992021-05-20 13:09:48 -07001321}
1322
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001323std::pair<bool, CameraProviderManager::ProviderInfo::DeviceInfo *>
1324CameraProviderManager::isHiddenPhysicalCameraInternal(const std::string& cameraId) const {
1325 auto falseRet = std::make_pair(false, nullptr);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001326 for (auto& provider : mProviders) {
1327 for (auto& deviceInfo : provider->mDevices) {
1328 if (deviceInfo->mId == cameraId) {
1329 // cameraId is found in public camera IDs advertised by the
1330 // provider.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001331 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001332 }
1333 }
1334 }
1335
1336 for (auto& provider : mProviders) {
1337 for (auto& deviceInfo : provider->mDevices) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001338 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001339 if (deviceInfo->mIsLogicalCamera) {
1340 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1341 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001342 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
1343 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
1344 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
1345 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
1346 __FUNCTION__, deviceVersion, cameraId.c_str());
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001347 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001348 } else {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001349 return std::make_pair(true, deviceInfo.get());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001350 }
1351 }
1352 }
1353 }
1354 }
1355
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001356 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001357}
1358
Emilian Peevc93cac22020-08-17 16:00:10 -07001359status_t CameraProviderManager::tryToInitializeProviderLocked(
1360 const std::string& providerName, const sp<ProviderInfo>& providerInfo) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001361 sp<provider::V2_4::ICameraProvider> interface;
Emilian Peevc93cac22020-08-17 16:00:10 -07001362 interface = mServiceProxy->tryGetService(providerName);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001363
1364 if (interface == nullptr) {
Shuzhen Wang77d04192021-04-02 12:33:54 -07001365 // The interface may not be started yet. In that case, this is not a
1366 // fatal error.
1367 ALOGW("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
Emilian Peevc93cac22020-08-17 16:00:10 -07001368 providerName.c_str());
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001369 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001370 }
1371
Emilian Peevc93cac22020-08-17 16:00:10 -07001372 return providerInfo->initialize(interface, mDeviceState);
1373}
1374
1375status_t CameraProviderManager::addProviderLocked(const std::string& newProvider,
1376 bool preexisting) {
1377 // Several camera provider instances can be temporarily present.
1378 // Defer initialization of a new instance until the older instance is properly removed.
1379 auto providerInstance = newProvider + "-" + std::to_string(mProviderInstanceId);
1380 bool providerPresent = false;
1381 for (const auto& providerInfo : mProviders) {
1382 if (providerInfo->mProviderName == newProvider) {
1383 ALOGW("%s: Camera provider HAL with name '%s' already registered",
1384 __FUNCTION__, newProvider.c_str());
Valentin Iftime29e2e152021-08-13 15:17:33 +02001385 // Do not add new instances for lazy HAL external provider
1386 if (preexisting || providerInfo->isExternalLazyHAL()) {
Emilian Peevc93cac22020-08-17 16:00:10 -07001387 return ALREADY_EXISTS;
Valentin Iftime29e2e152021-08-13 15:17:33 +02001388 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07001389 ALOGW("%s: The new provider instance will get initialized immediately after the"
1390 " currently present instance is removed!", __FUNCTION__);
1391 providerPresent = true;
1392 break;
1393 }
1394 }
1395 }
1396
1397 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, providerInstance, this);
1398 if (!providerPresent) {
1399 status_t res = tryToInitializeProviderLocked(newProvider, providerInfo);
1400 if (res != OK) {
1401 return res;
1402 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001403 }
1404
1405 mProviders.push_back(providerInfo);
Emilian Peevc93cac22020-08-17 16:00:10 -07001406 mProviderInstanceId++;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001407
1408 return OK;
1409}
1410
1411status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07001412 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001413 std::unique_lock<std::mutex> lock(mInterfaceMutex);
1414 std::vector<String8> removedDeviceIds;
1415 status_t res = NAME_NOT_FOUND;
Emilian Peevc93cac22020-08-17 16:00:10 -07001416 std::string removedProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001417 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
Emilian Peevc93cac22020-08-17 16:00:10 -07001418 if ((*it)->mProviderInstance == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001419 removedDeviceIds.reserve((*it)->mDevices.size());
1420 for (auto& deviceInfo : (*it)->mDevices) {
1421 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
1422 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001423 removedProviderName = (*it)->mProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001424 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001425 res = OK;
1426 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001427 }
1428 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001429 if (res != OK) {
1430 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1431 provider.c_str());
1432 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07001433 // Check if there are any newer camera instances from the same provider and try to
1434 // initialize.
1435 for (const auto& providerInfo : mProviders) {
1436 if (providerInfo->mProviderName == removedProviderName) {
1437 return tryToInitializeProviderLocked(removedProviderName, providerInfo);
1438 }
1439 }
1440
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001441 // Inform camera service of loss of presence for all the devices from this provider,
1442 // without lock held for reentrancy
1443 sp<StatusListener> listener = getStatusListener();
1444 if (listener != nullptr) {
1445 lock.unlock();
1446 for (auto& id : removedDeviceIds) {
1447 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1448 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001449 lock.lock();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001450 }
Emilian Peevc93cac22020-08-17 16:00:10 -07001451
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001452 }
1453 return res;
1454}
1455
1456sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1457 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001458}
1459
1460/**** Methods for ProviderInfo ****/
1461
1462
1463CameraProviderManager::ProviderInfo::ProviderInfo(
1464 const std::string &providerName,
Emilian Peevc93cac22020-08-17 16:00:10 -07001465 const std::string &providerInstance,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001466 CameraProviderManager *manager) :
1467 mProviderName(providerName),
Emilian Peevc93cac22020-08-17 16:00:10 -07001468 mProviderInstance(providerInstance),
Emilian Peev71c73a22017-03-21 16:35:51 +00001469 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001470 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001471 mManager(manager) {
1472 (void) mManager;
1473}
1474
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001475status_t CameraProviderManager::ProviderInfo::initialize(
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001476 sp<provider::V2_4::ICameraProvider>& interface,
1477 hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001478 status_t res = parseProviderName(mProviderName, &mType, &mId);
1479 if (res != OK) {
1480 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1481 return BAD_VALUE;
1482 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001483 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001484 mProviderName.c_str(), interface->isRemote());
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001485
1486 // Determine minor version
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001487 mMinorVersion = 4;
1488 auto cast2_6 = provider::V2_6::ICameraProvider::castFrom(interface);
1489 sp<provider::V2_6::ICameraProvider> interface2_6 = nullptr;
1490 if (cast2_6.isOk()) {
1491 interface2_6 = cast2_6;
1492 if (interface2_6 != nullptr) {
1493 mMinorVersion = 6;
1494 }
1495 }
1496 // We need to check again since cast2_6.isOk() succeeds even if the provider
1497 // version isn't actually 2.6.
1498 if (interface2_6 == nullptr){
1499 auto cast2_5 =
1500 provider::V2_5::ICameraProvider::castFrom(interface);
1501 sp<provider::V2_5::ICameraProvider> interface2_5 = nullptr;
1502 if (cast2_5.isOk()) {
1503 interface2_5 = cast2_5;
1504 if (interface != nullptr) {
1505 mMinorVersion = 5;
1506 }
1507 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08001508 } else {
1509 auto cast2_7 = provider::V2_7::ICameraProvider::castFrom(interface);
1510 if (cast2_7.isOk()) {
1511 sp<provider::V2_7::ICameraProvider> interface2_7 = cast2_7;
1512 if (interface2_7 != nullptr) {
1513 mMinorVersion = 7;
1514 }
1515 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001516 }
1517
Shuzhen Wangbdf75f92020-07-10 14:13:33 -07001518 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1519 // before setCallback returns
1520 hardware::Return<Status> status = interface->setCallback(this);
1521 if (!status.isOk()) {
1522 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1523 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1524 return DEAD_OBJECT;
1525 }
1526 if (status != Status::OK) {
1527 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1528 __FUNCTION__, mProviderName.c_str());
1529 return mapToStatusT(status);
1530 }
1531
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001532 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001533 if (!linked.isOk()) {
1534 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1535 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1536 return DEAD_OBJECT;
1537 } else if (!linked) {
1538 ALOGW("%s: Unable to link to provider '%s' death notifications",
1539 __FUNCTION__, mProviderName.c_str());
1540 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001541
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001542 if (!kEnableLazyHal) {
1543 // Save HAL reference indefinitely
1544 mSavedInterface = interface;
1545 } else {
1546 mActiveInterface = interface;
1547 }
1548
1549 ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
1550 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1551 notifyDeviceStateChange(currentDeviceState);
1552
1553 res = setUpVendorTags();
1554 if (res != OK) {
1555 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1556 __FUNCTION__, mProviderName.c_str());
1557 return res;
1558 }
1559
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001560 // Get initial list of camera devices, if any
1561 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001562 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001563 Status idStatus,
1564 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1565 status = idStatus;
1566 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001567 for (auto& name : cameraDeviceNames) {
1568 uint16_t major, minor;
1569 std::string type, id;
1570 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1571 if (res != OK) {
1572 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1573 status = Status::INTERNAL_ERROR;
1574 } else {
1575 devices.push_back(name);
1576 mProviderPublicCameraIds.push_back(id);
1577 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001578 }
1579 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001580 if (!ret.isOk()) {
1581 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1582 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1583 return DEAD_OBJECT;
1584 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001585 if (status != Status::OK) {
1586 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1587 __FUNCTION__, mProviderName.c_str());
1588 return mapToStatusT(status);
1589 }
1590
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001591 // Get list of concurrent streaming camera device combinations
1592 if (mMinorVersion >= 6) {
Jayant Chowdharycad23c22020-03-10 15:04:59 -07001593 res = getConcurrentCameraIdsInternalLocked(interface2_6);
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001594 if (res != OK) {
1595 return res;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08001596 }
1597 }
1598
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001599 ret = interface->isSetTorchModeSupported(
1600 [this](auto status, bool supported) {
1601 if (status == Status::OK) {
1602 mSetTorchModeSupported = supported;
1603 }
1604 });
1605 if (!ret.isOk()) {
1606 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1607 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1608 return DEAD_OBJECT;
1609 }
1610
1611 mIsRemote = interface->isRemote();
1612
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001613 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001614 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001615 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001616 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001617 if (res != OK) {
1618 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1619 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001620 continue;
1621 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001622 }
1623
1624 ALOGI("Camera provider %s ready with %zu camera devices",
1625 mProviderName.c_str(), mDevices.size());
1626
Shuzhen Wang394ad702020-07-23 13:01:54 -07001627 // Process cached status callbacks
1628 std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus =
1629 std::make_unique<std::vector<CameraStatusInfoT>>();
1630 {
1631 std::lock_guard<std::mutex> lock(mInitLock);
1632
1633 for (auto& statusInfo : mCachedStatus) {
1634 std::string id, physicalId;
1635 status_t res = OK;
1636 if (statusInfo.isPhysicalCameraStatus) {
1637 res = physicalCameraDeviceStatusChangeLocked(&id, &physicalId,
1638 statusInfo.cameraId, statusInfo.physicalCameraId, statusInfo.status);
1639 } else {
1640 res = cameraDeviceStatusChangeLocked(&id, statusInfo.cameraId, statusInfo.status);
1641 }
1642 if (res == OK) {
1643 cachedStatus->emplace_back(statusInfo.isPhysicalCameraStatus,
1644 id.c_str(), physicalId.c_str(), statusInfo.status);
1645 }
1646 }
1647 mCachedStatus.clear();
1648
1649 mInitialized = true;
1650 }
1651
1652 // The cached status change callbacks cannot be fired directly from this
1653 // function, due to same-thread deadlock trying to acquire mInterfaceMutex
1654 // twice.
1655 if (listener != nullptr) {
1656 mInitialStatusCallbackFuture = std::async(std::launch::async,
1657 &CameraProviderManager::ProviderInfo::notifyInitialStatusChange, this,
1658 listener, std::move(cachedStatus));
1659 }
1660
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001661 return OK;
1662}
1663
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001664const sp<provider::V2_4::ICameraProvider>
1665CameraProviderManager::ProviderInfo::startProviderInterface() {
1666 ATRACE_CALL();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001667 ALOGV("Request to start camera provider: %s", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001668 if (mSavedInterface != nullptr) {
1669 return mSavedInterface;
1670 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001671 if (!kEnableLazyHal) {
1672 ALOGE("Bad provider state! Should not be here on a non-lazy HAL!");
1673 return nullptr;
1674 }
1675
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001676 auto interface = mActiveInterface.promote();
1677 if (interface == nullptr) {
Valentin Iftime29e2e152021-08-13 15:17:33 +02001678 // Try to get service without starting
1679 interface = mManager->mServiceProxy->tryGetService(mProviderName);
1680 if (interface == nullptr) {
1681 ALOGV("Camera provider actually needs restart, calling getService(%s)",
1682 mProviderName.c_str());
1683 interface = mManager->mServiceProxy->getService(mProviderName);
1684
1685 // Set all devices as ENUMERATING, provider should update status
1686 // to PRESENT after initializing.
1687 // This avoids failing getCameraDeviceInterface_V3_x before devices
1688 // are ready.
1689 for (auto& device : mDevices) {
1690 device->mIsDeviceAvailable = false;
1691 }
1692
1693 interface->setCallback(this);
1694 hardware::Return<bool>
1695 linked = interface->linkToDeath(this, /*cookie*/ mId);
1696 if (!linked.isOk()) {
1697 ALOGE(
1698 "%s: Transaction error in linking to camera provider '%s' death: %s",
1699 __FUNCTION__,
1700 mProviderName.c_str(),
1701 linked.description().c_str());
1702 mManager->removeProvider(mProviderName);
1703 return nullptr;
1704 } else if (!linked) {
1705 ALOGW("%s: Unable to link to provider '%s' death notifications",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001706 __FUNCTION__, mProviderName.c_str());
Valentin Iftime29e2e152021-08-13 15:17:33 +02001707 }
1708 // Send current device state
1709 if (mMinorVersion >= 5) {
1710 auto castResult =
1711 provider::V2_5::ICameraProvider::castFrom(interface);
1712 if (castResult.isOk()) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001713 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1714 if (interface_2_5 != nullptr) {
Valentin Iftime29e2e152021-08-13 15:17:33 +02001715 ALOGV("%s: Initial device state for %s: 0x %" PRIx64,
1716 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1717 interface_2_5->notifyDeviceStateChange(mDeviceState);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001718 }
Valentin Iftime29e2e152021-08-13 15:17:33 +02001719 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001720 }
1721 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001722 mActiveInterface = interface;
1723 } else {
Valentin Iftime29e2e152021-08-13 15:17:33 +02001724 ALOGV("Camera provider (%s) already in use. Re-using instance.",
1725 mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001726 }
Valentin Iftime29e2e152021-08-13 15:17:33 +02001727
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001728 return interface;
1729}
1730
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001731const std::string& CameraProviderManager::ProviderInfo::getType() const {
1732 return mType;
1733}
1734
1735status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1736 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1737
1738 ALOGI("Enumerating new camera device: %s", name.c_str());
1739
1740 uint16_t major, minor;
1741 std::string type, id;
1742
1743 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1744 if (res != OK) {
1745 return res;
1746 }
1747 if (type != mType) {
1748 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1749 type.c_str(), mType.c_str());
1750 return BAD_VALUE;
1751 }
1752 if (mManager->isValidDeviceLocked(id, major)) {
1753 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1754 name.c_str(), id.c_str(), major);
1755 return BAD_VALUE;
1756 }
1757
1758 std::unique_ptr<DeviceInfo> deviceInfo;
1759 switch (major) {
1760 case 1:
Eino-Ville Talvalaa976df82019-06-13 18:01:58 -07001761 ALOGE("%s: Device %s: Unsupported HIDL device HAL major version %d:", __FUNCTION__,
1762 name.c_str(), major);
1763 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001764 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001765 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1766 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001767 break;
1768 default:
1769 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1770 name.c_str(), major);
1771 return BAD_VALUE;
1772 }
1773 if (deviceInfo == nullptr) return BAD_VALUE;
Emilian Peev3486ab72021-10-25 18:24:19 -07001774 deviceInfo->notifyDeviceStateChange(mDeviceState);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001775 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001776 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001777
1778 mDevices.push_back(std::move(deviceInfo));
1779
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001780 mUniqueCameraIds.insert(id);
1781 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001782 // addDevice can be called more than once for the same camera id if HAL
1783 // supports openLegacy.
1784 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1785 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1786 mUniqueAPI1CompatibleCameraIds.push_back(id);
1787 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001788 }
1789
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001790 if (parsedId != nullptr) {
1791 *parsedId = id;
1792 }
1793 return OK;
1794}
1795
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001796void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1797 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1798 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001799 mUniqueCameraIds.erase(id);
1800 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001801 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
Valentin Iftime29e2e152021-08-13 15:17:33 +02001802 mUniqueAPI1CompatibleCameraIds.begin(),
1803 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001804 }
Valentin Iftime29e2e152021-08-13 15:17:33 +02001805
1806 // Remove reference to camera provider to avoid pointer leak when
1807 // unplugging external camera while in use with lazy HALs
1808 mManager->removeRef(DeviceMode::CAMERA, id);
1809 mManager->removeRef(DeviceMode::TORCH, id);
1810
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001811 mDevices.erase(it);
1812 break;
1813 }
1814 }
1815}
1816
Valentin Iftime29e2e152021-08-13 15:17:33 +02001817void CameraProviderManager::ProviderInfo::removeAllDevices() {
1818 std::lock_guard<std::mutex> lock(mLock);
1819
1820 auto itDevices = mDevices.begin();
1821 while (itDevices != mDevices.end()) {
1822 std::string id = (*itDevices)->mId;
1823 std::string deviceName = (*itDevices)->mName;
1824 removeDevice(id);
1825 // device was removed, reset iterator
1826 itDevices = mDevices.begin();
1827
1828 //notify CameraService of status change
1829 sp<StatusListener> listener = mManager->getStatusListener();
1830 if (listener != nullptr) {
1831 mLock.unlock();
1832 ALOGV("%s: notify device not_present: %s",
1833 __FUNCTION__,
1834 deviceName.c_str());
1835 listener->onDeviceStatusChanged(String8(id.c_str()),
1836 CameraDeviceStatus::NOT_PRESENT);
1837 mLock.lock();
1838 }
1839 }
1840}
1841
1842bool CameraProviderManager::ProviderInfo::isExternalLazyHAL() const {
1843 return kEnableLazyHal && (mProviderName == kExternalProviderName);
1844}
1845
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001846status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001847 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
Emilian Peevc93cac22020-08-17 16:00:10 -07001848 mProviderInstance.c_str(),
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001849 mMinorVersion,
1850 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001851 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001852
1853 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001854 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1855 device->mVersion.get_major(), device->mVersion.get_minor());
1856 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1857 if (device->mResourceCost.conflictingDevices.size() == 0) {
1858 dprintf(fd, " Conflicting devices: None\n");
1859 } else {
1860 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001861 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001862 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001863 device->mResourceCost.conflictingDevices[i].c_str());
1864 }
1865 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001866 dprintf(fd, " API1 info:\n");
1867 dprintf(fd, " Has a flash unit: %s\n",
1868 device->hasFlashUnit() ? "true" : "false");
1869 hardware::CameraInfo info;
1870 status_t res = device->getCameraInfo(&info);
1871 if (res != OK) {
1872 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1873 strerror(-res), res);
1874 } else {
1875 dprintf(fd, " Facing: %s\n",
1876 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1877 dprintf(fd, " Orientation: %d\n", info.orientation);
1878 }
1879 CameraMetadata info2;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001880 res = device->getCameraCharacteristics(true /*overrideForPerfClass*/, &info2);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001881 if (res == INVALID_OPERATION) {
1882 dprintf(fd, " API2 not directly supported\n");
1883 } else if (res != OK) {
1884 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1885 strerror(-res), res);
1886 } else {
1887 dprintf(fd, " API2 camera characteristics:\n");
1888 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1889 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001890
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001891 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001892 if (device->mIsLogicalCamera) {
1893 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001894 // Skip if physical id is an independent camera
1895 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1896 != mProviderPublicCameraIds.end()) {
1897 continue;
1898 }
1899
1900 CameraMetadata physicalInfo;
1901 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1902 if (status == OK) {
1903 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1904 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1905 }
1906 }
1907 }
1908
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001909 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1910 device->mVersion.get_major(), device->mVersion.get_minor());
1911 res = device->dumpState(fd);
1912 if (res != OK) {
1913 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1914 device->mName.c_str(), strerror(-res), res);
1915 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001916 }
1917 return OK;
1918}
1919
Jayant Chowdharycad23c22020-03-10 15:04:59 -07001920status_t CameraProviderManager::ProviderInfo::getConcurrentCameraIdsInternalLocked(
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001921 sp<provider::V2_6::ICameraProvider> &interface2_6) {
1922 if (interface2_6 == nullptr) {
1923 ALOGE("%s: null interface provided", __FUNCTION__);
1924 return BAD_VALUE;
1925 }
1926 Status status = Status::OK;
1927 hardware::Return<void> ret =
1928 interface2_6->getConcurrentStreamingCameraIds([&status, this](
1929 Status concurrentIdStatus, // TODO: Move all instances of hidl_string to 'using'
1930 const hardware::hidl_vec<hardware::hidl_vec<hardware::hidl_string>>&
1931 cameraDeviceIdCombinations) {
1932 status = concurrentIdStatus;
1933 if (status == Status::OK) {
1934 mConcurrentCameraIdCombinations.clear();
1935 for (auto& combination : cameraDeviceIdCombinations) {
1936 std::unordered_set<std::string> deviceIds;
1937 for (auto &cameraDeviceId : combination) {
1938 deviceIds.insert(cameraDeviceId.c_str());
1939 }
1940 mConcurrentCameraIdCombinations.push_back(std::move(deviceIds));
1941 }
1942 } });
1943 if (!ret.isOk()) {
1944 ALOGE("%s: Transaction error in getting concurrent camera ID list from provider '%s'",
1945 __FUNCTION__, mProviderName.c_str());
1946 return DEAD_OBJECT;
1947 }
1948 if (status != Status::OK) {
1949 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1950 __FUNCTION__, mProviderName.c_str());
1951 return mapToStatusT(status);
1952 }
1953 return OK;
1954}
1955
1956status_t CameraProviderManager::ProviderInfo::reCacheConcurrentStreamingCameraIdsLocked() {
1957 if (mMinorVersion < 6) {
1958 // Unsupported operation, nothing to do here
1959 return OK;
1960 }
1961 // Check if the provider is currently active - not going to start it up for this notification
1962 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
1963 if (interface == nullptr) {
1964 ALOGE("%s: camera provider interface for %s is not valid", __FUNCTION__,
1965 mProviderName.c_str());
1966 return INVALID_OPERATION;
1967 }
1968 auto castResult = provider::V2_6::ICameraProvider::castFrom(interface);
1969
1970 if (castResult.isOk()) {
1971 sp<provider::V2_6::ICameraProvider> interface2_6 = castResult;
1972 if (interface2_6 != nullptr) {
Jayant Chowdharycad23c22020-03-10 15:04:59 -07001973 return getConcurrentCameraIdsInternalLocked(interface2_6);
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08001974 } else {
1975 // This should not happen since mMinorVersion >= 6
1976 ALOGE("%s: mMinorVersion was >= 6, but interface2_6 was nullptr", __FUNCTION__);
1977 return UNKNOWN_ERROR;
1978 }
1979 }
1980 return OK;
1981}
1982
1983std::vector<std::unordered_set<std::string>>
1984CameraProviderManager::ProviderInfo::getConcurrentCameraIdCombinations() {
1985 std::lock_guard<std::mutex> lock(mLock);
1986 return mConcurrentCameraIdCombinations;
1987}
1988
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001989hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1990 const hardware::hidl_string& cameraDeviceName,
1991 CameraDeviceStatus newStatus) {
1992 sp<StatusListener> listener;
1993 std::string id;
Shuzhen Wang394ad702020-07-23 13:01:54 -07001994 std::lock_guard<std::mutex> lock(mInitLock);
1995
1996 if (!mInitialized) {
1997 mCachedStatus.emplace_back(false /*isPhysicalCameraStatus*/,
1998 cameraDeviceName.c_str(), std::string().c_str(), newStatus);
1999 return hardware::Void();
2000 }
2001
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002002 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002003 std::lock_guard<std::mutex> lock(mLock);
Shuzhen Wang394ad702020-07-23 13:01:54 -07002004 if (OK != cameraDeviceStatusChangeLocked(&id, cameraDeviceName, newStatus)) {
2005 return hardware::Void();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002006 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002007 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002008 }
Shuzhen Wang394ad702020-07-23 13:01:54 -07002009
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002010 // Call without lock held to allow reentrancy into provider manager
Shuzhen Wang394ad702020-07-23 13:01:54 -07002011 if (listener != nullptr) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002012 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
2013 }
Shuzhen Wang394ad702020-07-23 13:01:54 -07002014
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002015 return hardware::Void();
2016}
2017
Shuzhen Wang394ad702020-07-23 13:01:54 -07002018status_t CameraProviderManager::ProviderInfo::cameraDeviceStatusChangeLocked(
2019 std::string* id, const hardware::hidl_string& cameraDeviceName,
2020 CameraDeviceStatus newStatus) {
2021 bool known = false;
2022 std::string cameraId;
2023 for (auto& deviceInfo : mDevices) {
2024 if (deviceInfo->mName == cameraDeviceName) {
Valentin Iftime29e2e152021-08-13 15:17:33 +02002025 Mutex::Autolock l(deviceInfo->mDeviceAvailableLock);
Shuzhen Wang394ad702020-07-23 13:01:54 -07002026 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
2027 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
2028 deviceInfo->mStatus = newStatus;
2029 // TODO: Handle device removal (NOT_PRESENT)
2030 cameraId = deviceInfo->mId;
2031 known = true;
Valentin Iftime29e2e152021-08-13 15:17:33 +02002032 deviceInfo->mIsDeviceAvailable =
2033 (newStatus == CameraDeviceStatus::PRESENT);
2034 deviceInfo->mDeviceAvailableSignal.signal();
Shuzhen Wang394ad702020-07-23 13:01:54 -07002035 break;
2036 }
2037 }
2038 // Previously unseen device; status must not be NOT_PRESENT
2039 if (!known) {
2040 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
2041 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
2042 mProviderName.c_str(), cameraDeviceName.c_str());
2043 return BAD_VALUE;
2044 }
2045 addDevice(cameraDeviceName, newStatus, &cameraId);
2046 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
2047 removeDevice(cameraId);
Valentin Iftime29e2e152021-08-13 15:17:33 +02002048 } else if (isExternalLazyHAL()) {
2049 // Do not notify CameraService for PRESENT->PRESENT (lazy HAL restart)
2050 // because NOT_AVAILABLE is set on CameraService::connect and a PRESENT
2051 // notif. would overwrite it
2052 return BAD_VALUE;
Shuzhen Wang394ad702020-07-23 13:01:54 -07002053 }
2054 if (reCacheConcurrentStreamingCameraIdsLocked() != OK) {
2055 ALOGE("%s: CameraProvider %s could not re-cache concurrent streaming camera id list ",
2056 __FUNCTION__, mProviderName.c_str());
2057 }
2058 *id = cameraId;
2059 return OK;
2060}
2061
Shuzhen Wang43858162020-01-10 13:42:15 -08002062hardware::Return<void> CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChange(
2063 const hardware::hidl_string& cameraDeviceName,
2064 const hardware::hidl_string& physicalCameraDeviceName,
2065 CameraDeviceStatus newStatus) {
2066 sp<StatusListener> listener;
2067 std::string id;
Shuzhen Wang394ad702020-07-23 13:01:54 -07002068 std::string physicalId;
2069 std::lock_guard<std::mutex> lock(mInitLock);
2070
2071 if (!mInitialized) {
2072 mCachedStatus.emplace_back(true /*isPhysicalCameraStatus*/, cameraDeviceName,
2073 physicalCameraDeviceName, newStatus);
2074 return hardware::Void();
2075 }
2076
Shuzhen Wang43858162020-01-10 13:42:15 -08002077 {
2078 std::lock_guard<std::mutex> lock(mLock);
Shuzhen Wangbdf75f92020-07-10 14:13:33 -07002079
Shuzhen Wang394ad702020-07-23 13:01:54 -07002080 if (OK != physicalCameraDeviceStatusChangeLocked(&id, &physicalId, cameraDeviceName,
2081 physicalCameraDeviceName, newStatus)) {
Shuzhen Wang43858162020-01-10 13:42:15 -08002082 return hardware::Void();
2083 }
Shuzhen Wang394ad702020-07-23 13:01:54 -07002084
Shuzhen Wang43858162020-01-10 13:42:15 -08002085 listener = mManager->getStatusListener();
Shuzhen Wang43858162020-01-10 13:42:15 -08002086 }
2087 // Call without lock held to allow reentrancy into provider manager
Shuzhen Wangbdf75f92020-07-10 14:13:33 -07002088 if (listener != nullptr) {
Shuzhen Wang43858162020-01-10 13:42:15 -08002089 listener->onDeviceStatusChanged(String8(id.c_str()),
Shuzhen Wang394ad702020-07-23 13:01:54 -07002090 String8(physicalId.c_str()), newStatus);
Shuzhen Wang43858162020-01-10 13:42:15 -08002091 }
2092 return hardware::Void();
2093}
2094
Shuzhen Wang394ad702020-07-23 13:01:54 -07002095status_t CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChangeLocked(
2096 std::string* id, std::string* physicalId,
2097 const hardware::hidl_string& cameraDeviceName,
2098 const hardware::hidl_string& physicalCameraDeviceName,
2099 CameraDeviceStatus newStatus) {
2100 bool known = false;
2101 std::string cameraId;
2102 for (auto& deviceInfo : mDevices) {
2103 if (deviceInfo->mName == cameraDeviceName) {
2104 cameraId = deviceInfo->mId;
2105 if (!deviceInfo->mIsLogicalCamera) {
2106 ALOGE("%s: Invalid combination of camera id %s, physical id %s",
2107 __FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
2108 return BAD_VALUE;
2109 }
2110 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
2111 physicalCameraDeviceName) == deviceInfo->mPhysicalIds.end()) {
2112 ALOGE("%s: Invalid combination of camera id %s, physical id %s",
2113 __FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
2114 return BAD_VALUE;
2115 }
2116 ALOGI("Camera device %s physical device %s status is now %s",
2117 cameraDeviceName.c_str(), physicalCameraDeviceName.c_str(),
2118 deviceStatusToString(newStatus));
2119 known = true;
2120 break;
2121 }
2122 }
2123 // Previously unseen device; status must not be NOT_PRESENT
2124 if (!known) {
2125 ALOGW("Camera provider %s says an unknown camera device %s-%s is not present. Curious.",
2126 mProviderName.c_str(), cameraDeviceName.c_str(),
2127 physicalCameraDeviceName.c_str());
2128 return BAD_VALUE;
2129 }
2130
2131 *id = cameraId;
2132 *physicalId = physicalCameraDeviceName.c_str();
2133 return OK;
2134}
2135
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002136hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
2137 const hardware::hidl_string& cameraDeviceName,
2138 TorchModeStatus newStatus) {
2139 sp<StatusListener> listener;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002140 SystemCameraKind systemCameraKind = SystemCameraKind::PUBLIC;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002141 std::string id;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002142 bool known = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002143 {
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002144 // Hold mLock for accessing mDevices
2145 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002146 for (auto& deviceInfo : mDevices) {
2147 if (deviceInfo->mName == cameraDeviceName) {
2148 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
2149 torchStatusToString(newStatus));
2150 id = deviceInfo->mId;
2151 known = true;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002152 systemCameraKind = deviceInfo->mSystemCameraKind;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002153 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
2154 mManager->removeRef(DeviceMode::TORCH, id);
2155 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002156 break;
2157 }
2158 }
2159 if (!known) {
2160 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
2161 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
2162 return hardware::Void();
2163 }
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002164 // no lock needed since listener is set up only once during
2165 // CameraProviderManager initialization and then never changed till it is
2166 // destructed.
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002167 listener = mManager->getStatusListener();
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002168 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002169 // Call without lock held to allow reentrancy into provider manager
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002170 // The problem with holding mLock here is that we
2171 // might be limiting re-entrancy : CameraService::onTorchStatusChanged calls
2172 // back into CameraProviderManager which might try to hold mLock again (eg:
2173 // findDeviceInfo, which should be holding mLock while iterating through
2174 // each provider's devices).
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002175 if (listener != nullptr) {
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -07002176 listener->onTorchStatusChanged(String8(id.c_str()), newStatus, systemCameraKind);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002177 }
2178 return hardware::Void();
2179}
2180
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002181void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
2182 const wp<hidl::base::V1_0::IBase>& who) {
2183 (void) who;
Emilian Peevc93cac22020-08-17 16:00:10 -07002184 ALOGI("Camera provider '%s' has died; removing it", mProviderInstance.c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002185 if (cookie != mId) {
2186 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
2187 __FUNCTION__, cookie, mId);
2188 }
Emilian Peevc93cac22020-08-17 16:00:10 -07002189 mManager->removeProvider(mProviderInstance);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002190}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002191
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08002192status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
2193 if (mVendorTagDescriptor != nullptr)
2194 return OK;
2195
2196 hardware::hidl_vec<VendorTagSection> vts;
2197 Status status;
2198 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002199 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
2200 if (interface == nullptr) {
2201 return DEAD_OBJECT;
2202 }
2203 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08002204 [&](auto s, const auto& vendorTagSecs) {
2205 status = s;
2206 if (s == Status::OK) {
2207 vts = vendorTagSecs;
2208 }
2209 });
2210 if (!ret.isOk()) {
2211 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
2212 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
2213 return DEAD_OBJECT;
2214 }
2215 if (status != Status::OK) {
2216 return mapToStatusT(status);
2217 }
2218
2219 // Read all vendor tag definitions into a descriptor
2220 status_t res;
2221 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
2222 != OK) {
2223 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
2224 "received error %s (%d). Camera clients will not be able to use"
2225 "vendor tags", __FUNCTION__, strerror(res), res);
2226 return res;
2227 }
2228
2229 return OK;
2230}
2231
Emilian Peevb50402e2021-09-24 17:41:57 -07002232void CameraProviderManager::ProviderInfo::notifyDeviceInfoStateChangeLocked(
2233 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
2234 std::lock_guard<std::mutex> lock(mLock);
2235 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
2236 (*it)->notifyDeviceStateChange(newDeviceState);
2237 }
2238}
2239
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08002240status_t CameraProviderManager::ProviderInfo::notifyDeviceStateChange(
2241 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
2242 mDeviceState = newDeviceState;
2243 if (mMinorVersion >= 5) {
2244 // Check if the provider is currently active - not going to start it up for this notification
2245 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
2246 if (interface != nullptr) {
2247 // Send current device state
2248 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
2249 if (castResult.isOk()) {
2250 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
2251 if (interface_2_5 != nullptr) {
2252 interface_2_5->notifyDeviceStateChange(mDeviceState);
2253 }
2254 }
2255 }
2256 }
2257 return OK;
2258}
2259
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002260status_t CameraProviderManager::ProviderInfo::isConcurrentSessionConfigurationSupported(
2261 const hardware::hidl_vec<CameraIdAndStreamCombination> &halCameraIdsAndStreamCombinations,
2262 bool *isSupported) {
2263 status_t res = OK;
2264 if (mMinorVersion >= 6) {
2265 // Check if the provider is currently active - not going to start it up for this notification
2266 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
2267 if (interface == nullptr) {
2268 // TODO: This might be some other problem
2269 return INVALID_OPERATION;
2270 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002271 auto castResult2_6 = provider::V2_6::ICameraProvider::castFrom(interface);
2272 auto castResult2_7 = provider::V2_7::ICameraProvider::castFrom(interface);
2273 Status callStatus;
2274 auto cb =
2275 [&isSupported, &callStatus](Status s, bool supported) {
2276 callStatus = s;
2277 *isSupported = supported; };
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002278
Shuzhen Wang83bff122020-11-20 15:51:39 -08002279 ::android::hardware::Return<void> ret;
2280 sp<provider::V2_7::ICameraProvider> interface_2_7;
2281 sp<provider::V2_6::ICameraProvider> interface_2_6;
2282 if (mMinorVersion >= 7 && castResult2_7.isOk()) {
2283 interface_2_7 = castResult2_7;
2284 if (interface_2_7 != nullptr) {
2285 ret = interface_2_7->isConcurrentStreamCombinationSupported_2_7(
2286 halCameraIdsAndStreamCombinations, cb);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002287 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002288 } else if (mMinorVersion == 6 && castResult2_6.isOk()) {
2289 interface_2_6 = castResult2_6;
2290 if (interface_2_6 != nullptr) {
2291 hardware::hidl_vec<provider::V2_6::CameraIdAndStreamCombination>
2292 halCameraIdsAndStreamCombinations_2_6;
2293 size_t numStreams = halCameraIdsAndStreamCombinations.size();
2294 halCameraIdsAndStreamCombinations_2_6.resize(numStreams);
2295 for (size_t i = 0; i < numStreams; i++) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002296 using namespace camera3;
Shuzhen Wang83bff122020-11-20 15:51:39 -08002297 auto const& combination = halCameraIdsAndStreamCombinations[i];
2298 halCameraIdsAndStreamCombinations_2_6[i].cameraId = combination.cameraId;
2299 bool success =
2300 SessionConfigurationUtils::convertHALStreamCombinationFromV37ToV34(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002301 halCameraIdsAndStreamCombinations_2_6[i].streamConfiguration,
2302 combination.streamConfiguration);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002303 if (!success) {
2304 *isSupported = false;
2305 return OK;
2306 }
2307 }
2308 ret = interface_2_6->isConcurrentStreamCombinationSupported(
2309 halCameraIdsAndStreamCombinations_2_6, cb);
2310 }
2311 }
2312
2313 if (interface_2_7 != nullptr || interface_2_6 != nullptr) {
2314 if (ret.isOk()) {
2315 switch (callStatus) {
2316 case Status::OK:
2317 // Expected case, do nothing.
2318 res = OK;
2319 break;
2320 case Status::METHOD_NOT_SUPPORTED:
2321 res = INVALID_OPERATION;
2322 break;
2323 default:
2324 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__,
2325 callStatus);
2326 res = UNKNOWN_ERROR;
2327 }
2328 } else {
2329 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2330 res = UNKNOWN_ERROR;
2331 }
2332 return res;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002333 }
2334 }
2335 // unsupported operation
2336 return INVALID_OPERATION;
2337}
2338
Shuzhen Wang394ad702020-07-23 13:01:54 -07002339void CameraProviderManager::ProviderInfo::notifyInitialStatusChange(
2340 sp<StatusListener> listener,
2341 std::unique_ptr<std::vector<CameraStatusInfoT>> cachedStatus) {
2342 for (auto& statusInfo : *cachedStatus) {
2343 if (statusInfo.isPhysicalCameraStatus) {
2344 listener->onDeviceStatusChanged(String8(statusInfo.cameraId.c_str()),
2345 String8(statusInfo.physicalCameraId.c_str()), statusInfo.status);
2346 } else {
2347 listener->onDeviceStatusChanged(
2348 String8(statusInfo.cameraId.c_str()), statusInfo.status);
2349 }
2350 }
2351}
2352
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002353template<class DeviceInfoT>
2354std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
2355 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00002356 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002357 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002358 Status status;
2359
2360 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002361 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002362 if (cameraInterface == nullptr) return nullptr;
2363
2364 CameraResourceCost resourceCost;
2365 cameraInterface->getResourceCost([&status, &resourceCost](
2366 Status s, CameraResourceCost cost) {
2367 status = s;
2368 resourceCost = cost;
2369 });
2370 if (status != Status::OK) {
2371 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
2372 name.c_str(), statusToString(status));
2373 return nullptr;
2374 }
Shuzhen Wang47283692018-04-24 18:05:02 -07002375
2376 for (auto& conflictName : resourceCost.conflictingDevices) {
2377 uint16_t major, minor;
2378 std::string type, id;
2379 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
2380 if (res != OK) {
2381 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
2382 return nullptr;
2383 }
2384 conflictName = id;
2385 }
2386
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002387 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002388 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002389 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002390}
2391
2392template<class InterfaceT>
2393sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002394CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002395 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
2396 name.c_str(), InterfaceT::version.get_major());
2397 return nullptr;
2398}
2399
2400template<>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002401sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002402CameraProviderManager::ProviderInfo::startDeviceInterface
2403 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002404 Status status;
2405 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002406 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002407 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
2408 if (interface == nullptr) {
2409 return nullptr;
2410 }
2411 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002412 Status s, sp<device::V3_2::ICameraDevice> interface) {
2413 status = s;
2414 cameraInterface = interface;
2415 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002416 if (!ret.isOk()) {
2417 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
2418 __FUNCTION__, name.c_str(), ret.description().c_str());
2419 return nullptr;
2420 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002421 if (status != Status::OK) {
2422 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
2423 name.c_str(), statusToString(status));
2424 return nullptr;
2425 }
2426 return cameraInterface;
2427}
2428
2429CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
2430
2431template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002432sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
Valentin Iftime29e2e152021-08-13 15:17:33 +02002433 Mutex::Autolock l(mDeviceAvailableLock);
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002434 sp<InterfaceT> device;
2435 ATRACE_CALL();
2436 if (mSavedInterface == nullptr) {
Shuzhen Wang79680432020-03-05 11:53:46 -08002437 sp<ProviderInfo> parentProvider = mParentProvider.promote();
2438 if (parentProvider != nullptr) {
Valentin Iftime29e2e152021-08-13 15:17:33 +02002439 // Wait for lazy HALs to confirm device availability
2440 if (parentProvider->isExternalLazyHAL() && !mIsDeviceAvailable) {
2441 ALOGV("%s: Wait for external device to become available %s",
2442 __FUNCTION__,
2443 mId.c_str());
2444
2445 auto res = mDeviceAvailableSignal.waitRelative(mDeviceAvailableLock,
2446 kDeviceAvailableTimeout);
2447 if (res != OK) {
2448 ALOGE("%s: Failed waiting for device to become available",
2449 __FUNCTION__);
2450 return nullptr;
2451 }
2452 }
2453
Shuzhen Wang79680432020-03-05 11:53:46 -08002454 device = parentProvider->startDeviceInterface<InterfaceT>(mName);
2455 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002456 } else {
2457 device = (InterfaceT *) mSavedInterface.get();
2458 }
2459 return device;
2460}
2461
2462template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002463status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
2464 bool enabled) {
2465 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
2466 return mapToStatusT(s);
2467}
2468
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002469CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00002470 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002471 uint16_t minorVersion,
2472 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002473 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002474 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002475 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00002476 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002477 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002478 // Get camera characteristics and initialize flash unit availability
2479 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002480 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002481 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002482 device::V3_2::CameraMetadata metadata) {
2483 status = s;
2484 if (s == Status::OK) {
2485 camera_metadata_t *buffer =
2486 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07002487 size_t expectedSize = metadata.size();
2488 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2489 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2490 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2491 mCameraCharacteristics = buffer;
2492 } else {
2493 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2494 status = Status::INTERNAL_ERROR;
2495 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002496 }
2497 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002498 if (!ret.isOk()) {
2499 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002500 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002501 ret.description().c_str());
2502 return;
2503 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002504 if (status != Status::OK) {
2505 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002506 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002507 return;
2508 }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002509
Emilian Peevb50402e2021-09-24 17:41:57 -07002510 if (mCameraCharacteristics.exists(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS)) {
2511 const auto &stateMap = mCameraCharacteristics.find(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS);
2512 if ((stateMap.count > 0) && ((stateMap.count % 2) == 0)) {
2513 for (size_t i = 0; i < stateMap.count; i += 2) {
2514 mDeviceStateOrientationMap.emplace(stateMap.data.i64[i], stateMap.data.i64[i+1]);
2515 }
2516 } else {
2517 ALOGW("%s: Invalid ANDROID_INFO_DEVICE_STATE_ORIENTATIONS map size: %zu", __FUNCTION__,
2518 stateMap.count);
2519 }
2520 }
2521
Jayant Chowdhary5216b212019-07-17 09:26:23 -07002522 mSystemCameraKind = getSystemCameraKind();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002523
Shuzhen Wang268a1362018-10-16 16:32:59 -07002524 status_t res = fixupMonochromeTags();
2525 if (OK != res) {
2526 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
2527 __FUNCTION__, strerror(-res), res);
2528 return;
2529 }
Emilian Peeva1185162019-01-30 16:41:43 -08002530 auto stat = addDynamicDepthTags();
2531 if (OK != stat) {
2532 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-stat),
2533 stat);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00002534 }
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08002535 res = deriveHeicTags();
2536 if (OK != res) {
2537 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities: %s (%d)",
2538 __FUNCTION__, strerror(-res), res);
2539 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002540
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002541 if (SessionConfigurationUtils::isUltraHighResolutionSensor(mCameraCharacteristics)) {
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002542 status_t status = addDynamicDepthTags(/*maxResolution*/true);
2543 if (OK != status) {
2544 ALOGE("%s: Failed appending dynamic depth tags for maximum resolution mode: %s (%d)",
2545 __FUNCTION__, strerror(-status), status);
2546 }
2547
2548 status = deriveHeicTags(/*maxResolution*/true);
2549 if (OK != status) {
2550 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities for"
2551 "maximum resolution mode: %s (%d)", __FUNCTION__, strerror(-status), status);
2552 }
2553 }
2554
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08002555 res = addRotateCropTags();
2556 if (OK != res) {
2557 ALOGE("%s: Unable to add default SCALER_ROTATE_AND_CROP tags: %s (%d)", __FUNCTION__,
2558 strerror(-res), res);
2559 }
Shuzhen Wang9bf8a6f2020-05-01 09:49:04 -07002560 res = addPreCorrectionActiveArraySize();
2561 if (OK != res) {
2562 ALOGE("%s: Unable to add PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s (%d)", __FUNCTION__,
2563 strerror(-res), res);
2564 }
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08002565 res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
2566 &mCameraCharacteristics, &mSupportNativeZoomRatio);
2567 if (OK != res) {
2568 ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
2569 __FUNCTION__, strerror(-res), res);
2570 }
2571
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002572 camera_metadata_entry flashAvailable =
2573 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
2574 if (flashAvailable.count == 1 &&
2575 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
2576 mHasFlashUnit = true;
2577 } else {
2578 mHasFlashUnit = false;
2579 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002580
Rucha Katakwar38284522021-11-10 11:25:21 -08002581 camera_metadata_entry entry =
2582 mCameraCharacteristics.find(ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL);
2583 if (entry.count == 1) {
2584 mTorchDefaultStrengthLevel = entry.data.i32[0];
2585 } else {
2586 mTorchDefaultStrengthLevel = 0;
2587 }
2588
2589 entry = mCameraCharacteristics.find(ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL);
2590 if (entry.count == 1) {
2591 mTorchMaximumStrengthLevel = entry.data.i32[0];
2592 } else {
2593 mTorchMaximumStrengthLevel = 0;
2594 }
2595
2596 mTorchStrengthLevel = 0;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002597 queryPhysicalCameraIds();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002598
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002599 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002600 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002601 if (!castResult.isOk()) {
2602 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
2603 return;
2604 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002605 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002606 if (interface_3_5 == nullptr) {
2607 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
2608 return;
2609 }
2610
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002611 if (mIsLogicalCamera) {
2612 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002613 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
2614 mPublicCameraIds.end()) {
2615 continue;
2616 }
2617
2618 hardware::hidl_string hidlId(id);
2619 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
2620 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
2621 status = s;
2622 if (s == Status::OK) {
2623 camera_metadata_t *buffer =
2624 reinterpret_cast<camera_metadata_t*>(metadata.data());
2625 size_t expectedSize = metadata.size();
2626 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2627 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2628 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2629 mPhysicalCameraCharacteristics[id] = buffer;
2630 } else {
2631 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2632 status = Status::INTERNAL_ERROR;
2633 }
2634 }
2635 });
2636
2637 if (!ret.isOk()) {
2638 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002639 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002640 return;
2641 }
2642 if (status != Status::OK) {
2643 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
2644 __FUNCTION__, id.c_str(), mId.c_str(),
2645 CameraProviderManager::statusToString(status), status);
2646 return;
2647 }
Shuzhen Wang1c834da2019-12-18 11:17:03 -08002648
2649 res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
2650 &mPhysicalCameraCharacteristics[id], &mSupportNativeZoomRatio);
2651 if (OK != res) {
2652 ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
2653 __FUNCTION__, strerror(-res), res);
2654 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002655 }
2656 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002657
2658 if (!kEnableLazyHal) {
2659 // Save HAL reference indefinitely
2660 mSavedInterface = interface;
2661 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002662}
2663
2664CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
2665
Emilian Peevb50402e2021-09-24 17:41:57 -07002666void CameraProviderManager::ProviderInfo::DeviceInfo3::notifyDeviceStateChange(
2667 hardware::hidl_bitfield<hardware::camera::provider::V2_5::DeviceState> newState) {
2668
2669 if (!mDeviceStateOrientationMap.empty() &&
2670 (mDeviceStateOrientationMap.find(newState) != mDeviceStateOrientationMap.end())) {
2671 mCameraCharacteristics.update(ANDROID_SENSOR_ORIENTATION,
2672 &mDeviceStateOrientationMap[newState], 1);
2673 }
2674}
2675
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002676status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002677 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002678}
2679
Rucha Katakwar38284522021-11-10 11:25:21 -08002680status_t CameraProviderManager::ProviderInfo::DeviceInfo3::turnOnTorchWithStrengthLevel(
2681 int32_t torchStrength) {
2682 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2683 startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2684 if (interface == nullptr) {
2685 return DEAD_OBJECT;
2686 }
2687 sp<hardware::camera::device::V3_8::ICameraDevice> interface_3_8 = nullptr;
2688 auto castResult_3_8 = device::V3_8::ICameraDevice::castFrom(interface);
2689 if (castResult_3_8.isOk()) {
2690 interface_3_8 = castResult_3_8;
2691 }
2692
2693 if (interface_3_8 == nullptr) {
2694 return INVALID_OPERATION;
2695 }
2696
2697 Status s = interface_3_8->turnOnTorchWithStrengthLevel(torchStrength);
2698 if (s == Status::OK) {
2699 mTorchStrengthLevel = torchStrength;
2700 }
2701 return mapToStatusT(s);
2702}
2703
2704status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getTorchStrengthLevel(
2705 int32_t *torchStrength) {
2706 if (torchStrength == nullptr) {
2707 return BAD_VALUE;
2708 }
2709 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2710 startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2711 if (interface == nullptr) {
2712 return DEAD_OBJECT;
2713 }
2714 auto castResult_3_8 = device::V3_8::ICameraDevice::castFrom(interface);
2715 sp<hardware::camera::device::V3_8::ICameraDevice> interface_3_8 = nullptr;
2716 if (castResult_3_8.isOk()) {
2717 interface_3_8 = castResult_3_8;
2718 }
2719
2720 if (interface_3_8 == nullptr) {
2721 return INVALID_OPERATION;
2722 }
2723
2724 Status callStatus;
2725 status_t res;
2726 hardware::Return<void> ret = interface_3_8->getTorchStrengthLevel([&callStatus, &torchStrength]
2727 (Status status, const int32_t& torchStrengthLevel) {
2728 callStatus = status;
2729 if (status == Status::OK) {
2730 *torchStrength = torchStrengthLevel;
2731 } });
2732
2733 if (ret.isOk()) {
2734 switch (callStatus) {
2735 case Status::OK:
2736 // Expected case, do nothing.
2737 res = OK;
2738 break;
2739 case Status::METHOD_NOT_SUPPORTED:
2740 res = INVALID_OPERATION;
2741 break;
2742 default:
2743 ALOGE("%s: Get torch strength level failed: %d", __FUNCTION__, callStatus);
2744 res = UNKNOWN_ERROR;
2745 }
2746 } else {
2747 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2748 res = UNKNOWN_ERROR;
2749 }
2750
2751 return res;
2752}
2753
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002754status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
2755 hardware::CameraInfo *info) const {
2756 if (info == nullptr) return BAD_VALUE;
2757
2758 camera_metadata_ro_entry facing =
2759 mCameraCharacteristics.find(ANDROID_LENS_FACING);
2760 if (facing.count == 1) {
2761 switch (facing.data.u8[0]) {
2762 case ANDROID_LENS_FACING_BACK:
2763 info->facing = hardware::CAMERA_FACING_BACK;
2764 break;
2765 case ANDROID_LENS_FACING_EXTERNAL:
2766 // Map external to front for legacy API
2767 case ANDROID_LENS_FACING_FRONT:
2768 info->facing = hardware::CAMERA_FACING_FRONT;
2769 break;
2770 }
2771 } else {
2772 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
2773 return NAME_NOT_FOUND;
2774 }
2775
2776 camera_metadata_ro_entry orientation =
2777 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
2778 if (orientation.count == 1) {
2779 info->orientation = orientation.data.i32[0];
2780 } else {
2781 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
2782 return NAME_NOT_FOUND;
2783 }
2784
2785 return OK;
2786}
Emilian Peevf53f66e2017-04-11 14:29:43 +01002787bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07002788 // Do not advertise NIR cameras to API1 camera app.
2789 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
2790 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
2791 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
2792 return false;
2793 }
2794
Emilian Peevf53f66e2017-04-11 14:29:43 +01002795 bool isBackwardCompatible = false;
2796 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
2797 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
2798 for (size_t i = 0; i < caps.count; i++) {
2799 if (caps.data.u8[i] ==
2800 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2801 isBackwardCompatible = true;
2802 break;
2803 }
2804 }
2805
2806 return isBackwardCompatible;
2807}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002808
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002809status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002810 native_handle_t* handle = native_handle_create(1,0);
2811 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002812 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
2813 if (interface == nullptr) {
2814 return DEAD_OBJECT;
2815 }
2816 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002817 native_handle_delete(handle);
2818 if (!ret.isOk()) {
2819 return INVALID_OPERATION;
2820 }
2821 return OK;
2822}
2823
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002824status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002825 bool overrideForPerfClass, CameraMetadata *characteristics) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002826 if (characteristics == nullptr) return BAD_VALUE;
2827
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002828 if (!overrideForPerfClass && mCameraCharNoPCOverride != nullptr) {
2829 *characteristics = *mCameraCharNoPCOverride;
2830 } else {
2831 *characteristics = mCameraCharacteristics;
2832 }
2833
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002834 return OK;
2835}
2836
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002837status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
2838 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
2839 if (characteristics == nullptr) return BAD_VALUE;
2840 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
2841 mPhysicalCameraCharacteristics.end()) {
2842 return NAME_NOT_FOUND;
2843 }
2844
2845 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
2846 return OK;
2847}
2848
Emilian Peev35ae8262018-11-08 13:11:32 +00002849status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
Emilian Peev2295df72021-11-12 18:14:10 -08002850 const hardware::camera::device::V3_8::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002851 bool *status /*out*/) {
2852
2853 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2854 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2855 if (interface == nullptr) {
2856 return DEAD_OBJECT;
2857 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002858 auto castResult_3_5 = device::V3_5::ICameraDevice::castFrom(interface);
2859 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult_3_5;
2860 auto castResult_3_7 = device::V3_7::ICameraDevice::castFrom(interface);
2861 sp<hardware::camera::device::V3_7::ICameraDevice> interface_3_7 = castResult_3_7;
Emilian Peev2295df72021-11-12 18:14:10 -08002862 auto castResult_3_8 = device::V3_8::ICameraDevice::castFrom(interface);
2863 sp<hardware::camera::device::V3_8::ICameraDevice> interface_3_8 = castResult_3_8;
Emilian Peev35ae8262018-11-08 13:11:32 +00002864
2865 status_t res;
2866 Status callStatus;
Shuzhen Wang83bff122020-11-20 15:51:39 -08002867 ::android::hardware::Return<void> ret;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002868 auto halCb =
Emilian Peev35ae8262018-11-08 13:11:32 +00002869 [&callStatus, &status] (Status s, bool combStatus) {
2870 callStatus = s;
2871 *status = combStatus;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002872 };
Emilian Peev2295df72021-11-12 18:14:10 -08002873 if (interface_3_8 != nullptr) {
2874 ret = interface_3_8->isStreamCombinationSupported_3_8(configuration, halCb);
2875 } else if (interface_3_7 != nullptr) {
2876 hardware::camera::device::V3_7::StreamConfiguration configuration_3_7;
2877 bool success = SessionConfigurationUtils::convertHALStreamCombinationFromV38ToV37(
2878 configuration_3_7, configuration);
2879 if (!success) {
2880 *status = false;
2881 return OK;
2882 }
2883 ret = interface_3_7->isStreamCombinationSupported_3_7(configuration_3_7, halCb);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002884 } else if (interface_3_5 != nullptr) {
Emilian Peev2295df72021-11-12 18:14:10 -08002885 hardware::camera::device::V3_7::StreamConfiguration configuration_3_7;
2886 bool success = SessionConfigurationUtils::convertHALStreamCombinationFromV38ToV37(
2887 configuration_3_7, configuration);
2888 if (!success) {
2889 *status = false;
2890 return OK;
2891 }
Shuzhen Wang83bff122020-11-20 15:51:39 -08002892 hardware::camera::device::V3_4::StreamConfiguration configuration_3_4;
Emilian Peev2295df72021-11-12 18:14:10 -08002893 success = SessionConfigurationUtils::convertHALStreamCombinationFromV37ToV34(
2894 configuration_3_4, configuration_3_7);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002895 if (!success) {
2896 *status = false;
2897 return OK;
2898 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002899 ret = interface_3_5->isStreamCombinationSupported(configuration_3_4, halCb);
Shuzhen Wang83bff122020-11-20 15:51:39 -08002900 } else {
2901 return INVALID_OPERATION;
2902 }
Emilian Peev35ae8262018-11-08 13:11:32 +00002903 if (ret.isOk()) {
2904 switch (callStatus) {
2905 case Status::OK:
2906 // Expected case, do nothing.
2907 res = OK;
2908 break;
2909 case Status::METHOD_NOT_SUPPORTED:
2910 res = INVALID_OPERATION;
2911 break;
2912 default:
2913 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
2914 res = UNKNOWN_ERROR;
2915 }
2916 } else {
2917 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2918 res = UNKNOWN_ERROR;
2919 }
2920
2921 return res;
2922}
2923
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002924status_t CameraProviderManager::ProviderInfo::DeviceInfo3::filterSmallJpegSizes() {
2925 int32_t thresholdW = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_W;
2926 int32_t thresholdH = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_H;
2927
2928 if (mCameraCharNoPCOverride != nullptr) return OK;
2929
2930 mCameraCharNoPCOverride = std::make_unique<CameraMetadata>(mCameraCharacteristics);
Shuzhen Wang89db2992021-05-20 13:09:48 -07002931
2932 // Remove small JPEG sizes from available stream configurations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002933 size_t largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002934 std::vector<int32_t> newStreamConfigs;
2935 camera_metadata_entry streamConfigs =
2936 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
2937 for (size_t i = 0; i < streamConfigs.count; i += 4) {
2938 if ((streamConfigs.data.i32[i] == HAL_PIXEL_FORMAT_BLOB) && (streamConfigs.data.i32[i+3] ==
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002939 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
2940 if (streamConfigs.data.i32[i+1] < thresholdW ||
2941 streamConfigs.data.i32[i+2] < thresholdH) {
2942 continue;
2943 } else {
2944 largeJpegCount ++;
2945 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002946 }
2947 newStreamConfigs.insert(newStreamConfigs.end(), streamConfigs.data.i32 + i,
2948 streamConfigs.data.i32 + i + 4);
2949 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002950 if (newStreamConfigs.size() == 0 || largeJpegCount == 0) {
2951 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002952 }
2953
2954 // Remove small JPEG sizes from available min frame durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002955 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002956 std::vector<int64_t> newMinDurations;
2957 camera_metadata_entry minDurations =
2958 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
2959 for (size_t i = 0; i < minDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002960 if (minDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
2961 if (minDurations.data.i64[i+1] < thresholdW ||
2962 minDurations.data.i64[i+2] < thresholdH) {
2963 continue;
2964 } else {
2965 largeJpegCount++;
2966 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002967 }
2968 newMinDurations.insert(newMinDurations.end(), minDurations.data.i64 + i,
2969 minDurations.data.i64 + i + 4);
2970 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002971 if (newMinDurations.size() == 0 || largeJpegCount == 0) {
2972 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002973 }
2974
2975 // Remove small JPEG sizes from available stall durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002976 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002977 std::vector<int64_t> newStallDurations;
2978 camera_metadata_entry stallDurations =
2979 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS);
2980 for (size_t i = 0; i < stallDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002981 if (stallDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
2982 if (stallDurations.data.i64[i+1] < thresholdW ||
2983 stallDurations.data.i64[i+2] < thresholdH) {
2984 continue;
2985 } else {
2986 largeJpegCount++;
2987 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002988 }
2989 newStallDurations.insert(newStallDurations.end(), stallDurations.data.i64 + i,
2990 stallDurations.data.i64 + i + 4);
2991 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002992 if (newStallDurations.size() == 0 || largeJpegCount == 0) {
2993 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002994 }
2995
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002996 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
2997 newStreamConfigs.data(), newStreamConfigs.size());
2998 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
2999 newMinDurations.data(), newMinDurations.size());
3000 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
3001 newStallDurations.data(), newStallDurations.size());
3002
Shuzhen Wang89db2992021-05-20 13:09:48 -07003003 // Re-generate metadata tags that have dependencies on BLOB sizes
3004 auto res = addDynamicDepthTags();
3005 if (OK != res) {
3006 ALOGE("%s: Failed to append dynamic depth tags: %s (%d)", __FUNCTION__,
3007 strerror(-res), res);
Shuzhen Wang2ebb8392021-06-21 23:31:10 -07003008 // Allow filtering of small JPEG sizes to succeed even if dynamic depth
3009 // tags fail to generate.
Shuzhen Wang89db2992021-05-20 13:09:48 -07003010 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003011
3012 return OK;
Shuzhen Wang89db2992021-05-20 13:09:48 -07003013}
3014
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003015status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
3016 std::string *type, uint32_t *id) {
3017 // Format must be "<type>/<id>"
3018#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
3019 "Should match '<type>/<id>' - "
3020
3021 if (!type || !id) return INVALID_OPERATION;
3022
3023 std::string::size_type slashIdx = name.find('/');
3024 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
3025 ALOGE(ERROR_MSG_PREFIX
3026 "does not have / separator between type and id",
3027 __FUNCTION__, name.c_str());
3028 return BAD_VALUE;
3029 }
3030
3031 std::string typeVal = name.substr(0, slashIdx);
3032
3033 char *endPtr;
3034 errno = 0;
3035 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
3036 if (errno != 0) {
3037 ALOGE(ERROR_MSG_PREFIX
3038 "cannot parse provider id as an integer: %s (%d)",
3039 __FUNCTION__, name.c_str(), strerror(errno), errno);
3040 return BAD_VALUE;
3041 }
3042 if (endPtr != name.c_str() + name.size()) {
3043 ALOGE(ERROR_MSG_PREFIX
3044 "provider id has unexpected length",
3045 __FUNCTION__, name.c_str());
3046 return BAD_VALUE;
3047 }
3048 if (idVal < 0) {
3049 ALOGE(ERROR_MSG_PREFIX
3050 "id is negative: %ld",
3051 __FUNCTION__, name.c_str(), idVal);
3052 return BAD_VALUE;
3053 }
3054
3055#undef ERROR_MSG_PREFIX
3056
3057 *type = typeVal;
3058 *id = static_cast<uint32_t>(idVal);
3059
3060 return OK;
3061}
3062
Emilian Peev71c73a22017-03-21 16:35:51 +00003063metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
3064 const std::string &name) {
3065 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
3066 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
3067 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
3068 ret = 0;
3069 }
3070
3071 return ret;
3072}
3073
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003074status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
3075 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
3076
3077 // Format must be "device@<major>.<minor>/<type>/<id>"
3078
3079#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
3080 "Should match 'device@<major>.<minor>/<type>/<id>' - "
3081
3082 if (!major || !minor || !type || !id) return INVALID_OPERATION;
3083
3084 // Verify starting prefix
3085 const char expectedPrefix[] = "device@";
3086
3087 if (name.find(expectedPrefix) != 0) {
3088 ALOGE(ERROR_MSG_PREFIX
3089 "does not start with '%s'",
3090 __FUNCTION__, name.c_str(), expectedPrefix);
3091 return BAD_VALUE;
3092 }
3093
3094 // Extract major/minor versions
3095 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
3096 std::string::size_type dotIdx = name.find('.', atIdx);
3097 if (dotIdx == std::string::npos) {
3098 ALOGE(ERROR_MSG_PREFIX
3099 "does not have @<major>. version section",
3100 __FUNCTION__, name.c_str());
3101 return BAD_VALUE;
3102 }
3103 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
3104 if (typeSlashIdx == std::string::npos) {
3105 ALOGE(ERROR_MSG_PREFIX
3106 "does not have .<minor>/ version section",
3107 __FUNCTION__, name.c_str());
3108 return BAD_VALUE;
3109 }
3110
3111 char *endPtr;
3112 errno = 0;
3113 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
3114 if (errno != 0) {
3115 ALOGE(ERROR_MSG_PREFIX
3116 "cannot parse major version: %s (%d)",
3117 __FUNCTION__, name.c_str(), strerror(errno), errno);
3118 return BAD_VALUE;
3119 }
3120 if (endPtr != name.c_str() + dotIdx) {
3121 ALOGE(ERROR_MSG_PREFIX
3122 "major version has unexpected length",
3123 __FUNCTION__, name.c_str());
3124 return BAD_VALUE;
3125 }
3126 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
3127 if (errno != 0) {
3128 ALOGE(ERROR_MSG_PREFIX
3129 "cannot parse minor version: %s (%d)",
3130 __FUNCTION__, name.c_str(), strerror(errno), errno);
3131 return BAD_VALUE;
3132 }
3133 if (endPtr != name.c_str() + typeSlashIdx) {
3134 ALOGE(ERROR_MSG_PREFIX
3135 "minor version has unexpected length",
3136 __FUNCTION__, name.c_str());
3137 return BAD_VALUE;
3138 }
3139 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
3140 ALOGE(ERROR_MSG_PREFIX
3141 "major/minor version is out of range of uint16_t: %ld.%ld",
3142 __FUNCTION__, name.c_str(), majorVal, minorVal);
3143 return BAD_VALUE;
3144 }
3145
3146 // Extract type and id
3147
3148 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
3149 if (instanceSlashIdx == std::string::npos) {
3150 ALOGE(ERROR_MSG_PREFIX
3151 "does not have /<type>/ component",
3152 __FUNCTION__, name.c_str());
3153 return BAD_VALUE;
3154 }
3155 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
3156
3157 if (instanceSlashIdx == name.size() - 1) {
3158 ALOGE(ERROR_MSG_PREFIX
3159 "does not have an /<id> component",
3160 __FUNCTION__, name.c_str());
3161 return BAD_VALUE;
3162 }
3163 std::string idVal = name.substr(instanceSlashIdx + 1);
3164
3165#undef ERROR_MSG_PREFIX
3166
3167 *major = static_cast<uint16_t>(majorVal);
3168 *minor = static_cast<uint16_t>(minorVal);
3169 *type = typeVal;
3170 *id = idVal;
3171
3172 return OK;
3173}
3174
3175
3176
3177CameraProviderManager::ProviderInfo::~ProviderInfo() {
Shuzhen Wang394ad702020-07-23 13:01:54 -07003178 if (mInitialStatusCallbackFuture.valid()) {
3179 mInitialStatusCallbackFuture.wait();
3180 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003181 // Destruction of ProviderInfo is only supposed to happen when the respective
3182 // CameraProvider interface dies, so do not unregister callbacks.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003183}
3184
3185status_t CameraProviderManager::mapToStatusT(const Status& s) {
3186 switch(s) {
3187 case Status::OK:
3188 return OK;
3189 case Status::ILLEGAL_ARGUMENT:
3190 return BAD_VALUE;
3191 case Status::CAMERA_IN_USE:
3192 return -EBUSY;
3193 case Status::MAX_CAMERAS_IN_USE:
3194 return -EUSERS;
3195 case Status::METHOD_NOT_SUPPORTED:
3196 return UNKNOWN_TRANSACTION;
3197 case Status::OPERATION_NOT_SUPPORTED:
3198 return INVALID_OPERATION;
3199 case Status::CAMERA_DISCONNECTED:
3200 return DEAD_OBJECT;
3201 case Status::INTERNAL_ERROR:
3202 return INVALID_OPERATION;
3203 }
3204 ALOGW("Unexpected HAL status code %d", s);
3205 return INVALID_OPERATION;
3206}
3207
3208const char* CameraProviderManager::statusToString(const Status& s) {
3209 switch(s) {
3210 case Status::OK:
3211 return "OK";
3212 case Status::ILLEGAL_ARGUMENT:
3213 return "ILLEGAL_ARGUMENT";
3214 case Status::CAMERA_IN_USE:
3215 return "CAMERA_IN_USE";
3216 case Status::MAX_CAMERAS_IN_USE:
3217 return "MAX_CAMERAS_IN_USE";
3218 case Status::METHOD_NOT_SUPPORTED:
3219 return "METHOD_NOT_SUPPORTED";
3220 case Status::OPERATION_NOT_SUPPORTED:
3221 return "OPERATION_NOT_SUPPORTED";
3222 case Status::CAMERA_DISCONNECTED:
3223 return "CAMERA_DISCONNECTED";
3224 case Status::INTERNAL_ERROR:
3225 return "INTERNAL_ERROR";
3226 }
3227 ALOGW("Unexpected HAL status code %d", s);
3228 return "UNKNOWN_ERROR";
3229}
3230
3231const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
3232 switch(s) {
3233 case CameraDeviceStatus::NOT_PRESENT:
3234 return "NOT_PRESENT";
3235 case CameraDeviceStatus::PRESENT:
3236 return "PRESENT";
3237 case CameraDeviceStatus::ENUMERATING:
3238 return "ENUMERATING";
3239 }
3240 ALOGW("Unexpected HAL device status code %d", s);
3241 return "UNKNOWN_STATUS";
3242}
3243
3244const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
3245 switch(s) {
3246 case TorchModeStatus::NOT_AVAILABLE:
3247 return "NOT_AVAILABLE";
3248 case TorchModeStatus::AVAILABLE_OFF:
3249 return "AVAILABLE_OFF";
3250 case TorchModeStatus::AVAILABLE_ON:
3251 return "AVAILABLE_ON";
3252 }
3253 ALOGW("Unexpected HAL torch mode status code %d", s);
3254 return "UNKNOWN_STATUS";
3255}
3256
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003257
3258status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08003259 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003260 /*out*/
3261 sp<VendorTagDescriptor>& descriptor) {
3262
3263 int tagCount = 0;
3264
3265 for (size_t s = 0; s < vts.size(); s++) {
3266 tagCount += vts[s].tags.size();
3267 }
3268
3269 if (tagCount < 0 || tagCount > INT32_MAX) {
3270 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
3271 return BAD_VALUE;
3272 }
3273
3274 Vector<uint32_t> tagArray;
3275 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
3276 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
3277
3278
3279 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
3280 desc->mTagCount = tagCount;
3281
3282 SortedVector<String8> sections;
3283 KeyedVector<uint32_t, String8> tagToSectionMap;
3284
3285 int idx = 0;
3286 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08003287 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003288 const char *sectionName = section.sectionName.c_str();
3289 if (sectionName == NULL) {
3290 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
3291 return BAD_VALUE;
3292 }
3293 String8 sectionString(sectionName);
3294 sections.add(sectionString);
3295
3296 for (size_t j = 0; j < section.tags.size(); j++) {
3297 uint32_t tag = section.tags[j].tagId;
3298 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
3299 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
3300 return BAD_VALUE;
3301 }
3302
3303 tagArray.editItemAt(idx++) = section.tags[j].tagId;
3304
3305 const char *tagName = section.tags[j].tagName.c_str();
3306 if (tagName == NULL) {
3307 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
3308 return BAD_VALUE;
3309 }
3310 desc->mTagToNameMap.add(tag, String8(tagName));
3311 tagToSectionMap.add(tag, sectionString);
3312
3313 int tagType = (int) section.tags[j].tagType;
3314 if (tagType < 0 || tagType >= NUM_TYPES) {
3315 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
3316 return BAD_VALUE;
3317 }
3318 desc->mTagToTypeMap.add(tag, tagType);
3319 }
3320 }
3321
3322 desc->mSections = sections;
3323
3324 for (size_t i = 0; i < tagArray.size(); ++i) {
3325 uint32_t tag = tagArray[i];
3326 String8 sectionString = tagToSectionMap.valueFor(tag);
3327
3328 // Set up tag to section index map
3329 ssize_t index = sections.indexOf(sectionString);
3330 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
3331 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
3332
3333 // Set up reverse mapping
3334 ssize_t reverseIndex = -1;
3335 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
3336 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
3337 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
3338 }
3339 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
3340 }
3341
George Burgess IVa0b84962017-08-29 17:46:19 -07003342 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003343 return OK;
3344}
3345
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003346// Expects to have mInterfaceMutex locked
3347std::vector<std::unordered_set<std::string>>
Jayant Chowdharycad23c22020-03-10 15:04:59 -07003348CameraProviderManager::getConcurrentCameraIds() const {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003349 std::vector<std::unordered_set<std::string>> deviceIdCombinations;
3350 std::lock_guard<std::mutex> lock(mInterfaceMutex);
3351 for (auto &provider : mProviders) {
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08003352 for (auto &combinations : provider->getConcurrentCameraIdCombinations()) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003353 deviceIdCombinations.push_back(combinations);
3354 }
3355 }
3356 return deviceIdCombinations;
3357}
3358
3359status_t CameraProviderManager::convertToHALStreamCombinationAndCameraIdsLocked(
3360 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003361 const std::set<std::string>& perfClassPrimaryCameraIds,
3362 int targetSdkVersion,
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003363 hardware::hidl_vec<CameraIdAndStreamCombination> *halCameraIdsAndStreamCombinations,
3364 bool *earlyExit) {
3365 binder::Status bStatus = binder::Status::ok();
3366 std::vector<CameraIdAndStreamCombination> halCameraIdsAndStreamsV;
3367 bool shouldExit = false;
3368 status_t res = OK;
3369 for (auto &cameraIdAndSessionConfig : cameraIdsAndSessionConfigs) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003370 const std::string& cameraId = cameraIdAndSessionConfig.mCameraId;
Emilian Peev2295df72021-11-12 18:14:10 -08003371 hardware::camera::device::V3_8::StreamConfiguration streamConfiguration;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003372 CameraMetadata deviceInfo;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003373 bool overrideForPerfClass =
3374 SessionConfigurationUtils::targetPerfClassPrimaryCamera(
3375 perfClassPrimaryCameraIds, cameraId, targetSdkVersion);
3376 res = getCameraCharacteristicsLocked(cameraId, overrideForPerfClass, &deviceInfo);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003377 if (res != OK) {
3378 return res;
3379 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08003380 camera3::metadataGetter getMetadata =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003381 [this](const String8 &id, bool overrideForPerfClass) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003382 CameraMetadata physicalDeviceInfo;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003383 getCameraCharacteristicsLocked(id.string(), overrideForPerfClass,
3384 &physicalDeviceInfo);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003385 return physicalDeviceInfo;
3386 };
3387 std::vector<std::string> physicalCameraIds;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003388 isLogicalCameraLocked(cameraId, &physicalCameraIds);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003389 bStatus =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003390 SessionConfigurationUtils::convertToHALStreamCombination(
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003391 cameraIdAndSessionConfig.mSessionConfiguration,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003392 String8(cameraId.c_str()), deviceInfo, getMetadata,
3393 physicalCameraIds, streamConfiguration,
3394 overrideForPerfClass, &shouldExit);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003395 if (!bStatus.isOk()) {
3396 ALOGE("%s: convertToHALStreamCombination failed", __FUNCTION__);
3397 return INVALID_OPERATION;
3398 }
3399 if (shouldExit) {
3400 *earlyExit = true;
3401 return OK;
3402 }
3403 CameraIdAndStreamCombination halCameraIdAndStream;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003404 halCameraIdAndStream.cameraId = cameraId;
Emilian Peev2295df72021-11-12 18:14:10 -08003405 SessionConfigurationUtils::convertHALStreamCombinationFromV38ToV37(
3406 halCameraIdAndStream.streamConfiguration, streamConfiguration);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003407 halCameraIdsAndStreamsV.push_back(halCameraIdAndStream);
3408 }
3409 *halCameraIdsAndStreamCombinations = halCameraIdsAndStreamsV;
3410 return OK;
3411}
3412
3413// Checks if the containing vector of sets has any set that contains all of the
3414// camera ids in cameraIdsAndSessionConfigs.
3415static bool checkIfSetContainsAll(
3416 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
3417 const std::vector<std::unordered_set<std::string>> &containingSets) {
3418 for (auto &containingSet : containingSets) {
3419 bool didHaveAll = true;
3420 for (auto &cameraIdAndSessionConfig : cameraIdsAndSessionConfigs) {
3421 if (containingSet.find(cameraIdAndSessionConfig.mCameraId) == containingSet.end()) {
3422 // a camera id doesn't belong to this set, keep looking in other
3423 // sets
3424 didHaveAll = false;
3425 break;
3426 }
3427 }
3428 if (didHaveAll) {
3429 // found a set that has all camera ids, lets return;
3430 return true;
3431 }
3432 }
3433 return false;
3434}
3435
3436status_t CameraProviderManager::isConcurrentSessionConfigurationSupported(
3437 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003438 const std::set<std::string>& perfClassPrimaryCameraIds,
3439 int targetSdkVersion, bool *isSupported) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003440 std::lock_guard<std::mutex> lock(mInterfaceMutex);
3441 // Check if all the devices are a subset of devices advertised by the
3442 // same provider through getConcurrentStreamingCameraIds()
3443 // TODO: we should also do a findDeviceInfoLocked here ?
3444 for (auto &provider : mProviders) {
3445 if (checkIfSetContainsAll(cameraIdsAndSessionConfigs,
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08003446 provider->getConcurrentCameraIdCombinations())) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003447 // For each camera device in cameraIdsAndSessionConfigs collect
3448 // the streamConfigs and create the HAL
3449 // CameraIdAndStreamCombination, exit early if needed
3450 hardware::hidl_vec<CameraIdAndStreamCombination> halCameraIdsAndStreamCombinations;
3451 bool knowUnsupported = false;
3452 status_t res = convertToHALStreamCombinationAndCameraIdsLocked(
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003453 cameraIdsAndSessionConfigs, perfClassPrimaryCameraIds,
3454 targetSdkVersion, &halCameraIdsAndStreamCombinations, &knowUnsupported);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003455 if (res != OK) {
3456 ALOGE("%s unable to convert session configurations provided to HAL stream"
3457 "combinations", __FUNCTION__);
3458 return res;
3459 }
3460 if (knowUnsupported) {
3461 // We got to know the streams aren't valid before doing the HAL
3462 // call itself.
3463 *isSupported = false;
3464 return OK;
3465 }
3466 return provider->isConcurrentSessionConfigurationSupported(
3467 halCameraIdsAndStreamCombinations, isSupported);
3468 }
3469 }
3470 *isSupported = false;
3471 //The set of camera devices were not found
3472 return INVALID_OPERATION;
3473}
3474
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003475status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003476 bool overrideForPerfClass, CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003477 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
3478 if (deviceInfo != nullptr) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003479 return deviceInfo->getCameraCharacteristics(overrideForPerfClass, characteristics);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003480 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003481
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003482 // Find hidden physical camera characteristics
3483 for (auto& provider : mProviders) {
3484 for (auto& deviceInfo : provider->mDevices) {
3485 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
3486 if (res != NAME_NOT_FOUND) return res;
3487 }
3488 }
3489
3490 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003491}
3492
3493void CameraProviderManager::filterLogicalCameraIdsLocked(
3494 std::vector<std::string>& deviceIds) const
3495{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003496 // Map between camera facing and camera IDs related to logical camera.
3497 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003498
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003499 // Collect all logical and its underlying physical camera IDs for each
3500 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003501 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07003502 auto deviceInfo = findDeviceInfoLocked(deviceId);
3503 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003504
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07003505 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003506 continue;
3507 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003508
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003509 // combo contains the ids of a logical camera and its physical cameras
3510 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
3511 combo.push_back(deviceId);
3512
3513 hardware::CameraInfo info;
3514 status_t res = deviceInfo->getCameraInfo(&info);
3515 if (res != OK) {
3516 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
3517 continue;
3518 }
3519 idCombos[info.facing].insert(combo.begin(), combo.end());
3520 }
3521
3522 // Only expose one camera ID per facing for all logical and underlying
3523 // physical camera IDs.
3524 for (auto& r : idCombos) {
3525 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003526 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003527 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
3528 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003529 continue;
3530 }
3531
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003532 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003533 break;
3534 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003535 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
3536 [&removedIds](const std::string& s) {
3537 return removedIds.find(s) != removedIds.end();}),
3538 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003539 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003540}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003541
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003542} // namespace android