blob: 9bc596b43b0837b419247ea5643fb77f0738685c [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
Emilian Peev434248e2022-10-06 14:58:54 -070017#include "system/graphics-base-v1.0.h"
18#include "system/graphics-base-v1.1.h"
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080019#define LOG_TAG "CameraProviderManager"
20#define ATRACE_TAG ATRACE_TAG_CAMERA
21//#define LOG_NDEBUG 0
22
23#include "CameraProviderManager.h"
24
Jayant Chowdharya04055f2022-01-03 02:07:49 +000025#include <aidl/android/hardware/camera/device/ICameraDevice.h>
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070026
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080027#include <algorithm>
Yin-Chia Yeh65405092017-01-13 15:42:28 -080028#include <chrono>
Emilian Peevcbf174b2019-01-25 14:38:59 -080029#include "common/DepthPhotoProcessor.h"
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070030#include "hidl/HidlProviderInfo.h"
Jayant Chowdharya04055f2022-01-03 02:07:49 +000031#include "aidl/AidlProviderInfo.h"
Emilian Peevcbf174b2019-01-25 14:38:59 -080032#include <dlfcn.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070033#include <future>
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070034#include <inttypes.h>
Jan Sebechlebskya79c9392023-11-17 16:03:25 +010035#include <android_companion_virtualdevice_flags.h>
Jan Sebechlebsky2f66b5e2024-01-16 17:00:26 +010036#include <android_companion_virtualdevice_build_flags.h>
Jayant Chowdharya04055f2022-01-03 02:07:49 +000037#include <android/binder_manager.h>
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070038#include <android/hidl/manager/1.2/IServiceManager.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080039#include <hidl/ServiceManagement.h>
Jayant Chowdharyd65d9442023-07-11 01:18:06 +000040#include <com_android_internal_camera_flags.h>
Jayant Chowdhary81d81b02024-02-15 19:13:39 +000041#include <com_android_window_flags.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000042#include <functional>
43#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080044#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070045#include <android-base/logging.h>
46#include <cutils/properties.h>
47#include <hwbinder/IPCThreadState.h>
48#include <utils/Trace.h>
Emilian Peev434248e2022-10-06 14:58:54 -070049#include <ui/PublicFormat.h>
Austin Borger1c1bee02023-06-01 16:51:35 -070050#include <camera/StringUtils.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080051
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080052#include "api2/HeicCompositeStream.h"
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -080053#include "device3/ZoomRatioMapper.h"
Eino-Ville Talvalab7723202024-06-24 17:45:51 -070054#include "utils/Utils.h"
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080055
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080056namespace android {
57
58using namespace ::android::hardware::camera;
Austin Borgerea931242021-12-13 23:10:41 +000059using namespace ::android::camera3;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070060using android::hardware::camera::common::V1_0::Status;
61using namespace camera3::SessionConfigurationUtils;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070062using std::literals::chrono_literals::operator""s;
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080063using hardware::camera2::utils::CameraIdAndSessionConfiguration;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080064
Jayant Chowdharyd65d9442023-07-11 01:18:06 +000065namespace flags = com::android::internal::camera::flags;
Jan Sebechlebskya79c9392023-11-17 16:03:25 +010066namespace vd_flags = android::companion::virtualdevice::flags;
Jayant Chowdhary81d81b02024-02-15 19:13:39 +000067namespace wm_flags = com::android::window::flags;
Jayant Chowdharyd65d9442023-07-11 01:18:06 +000068
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080069namespace {
Peter Kalauskasa29c1352018-10-10 12:05:42 -070070const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
Valentin Iftime29e2e152021-08-13 15:17:33 +020071const std::string kExternalProviderName = "external/0";
Vadim Caen7eccd7c2023-10-03 16:26:33 +020072const std::string kVirtualProviderName = "virtual/0";
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080073} // anonymous namespace
74
Emilian Peev538c90e2018-12-17 18:03:19 +000075const float CameraProviderManager::kDepthARTolerance = .1f;
Emilian Peev434248e2022-10-06 14:58:54 -070076const bool CameraProviderManager::kFrameworkJpegRDisabled =
77 property_get_bool("ro.camera.disableJpegR", false);
Emilian Peev538c90e2018-12-17 18:03:19 +000078
Jayant Chowdhary0bd38522021-11-05 17:49:27 -070079CameraProviderManager::HidlServiceInteractionProxyImpl
80CameraProviderManager::sHidlServiceInteractionProxy{};
Vadim Caen7eccd7c2023-10-03 16:26:33 +020081CameraProviderManager::AidlServiceInteractionProxyImpl
82CameraProviderManager::sAidlServiceInteractionProxy{};
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080083
84CameraProviderManager::~CameraProviderManager() {
85}
86
Jayant Chowdharya04055f2022-01-03 02:07:49 +000087const char* FrameworkTorchStatusToString(const TorchModeStatus& s) {
88 switch (s) {
89 case TorchModeStatus::NOT_AVAILABLE:
90 return "NOT_AVAILABLE";
91 case TorchModeStatus::AVAILABLE_OFF:
92 return "AVAILABLE_OFF";
93 case TorchModeStatus::AVAILABLE_ON:
94 return "AVAILABLE_ON";
95 }
Eino-Ville Talvalab7723202024-06-24 17:45:51 -070096 ALOGW("Unexpected HAL torch mode status code %d", eToI(s));
Jayant Chowdharya04055f2022-01-03 02:07:49 +000097 return "UNKNOWN_STATUS";
98}
99
100const char* FrameworkDeviceStatusToString(const CameraDeviceStatus& s) {
101 switch (s) {
102 case CameraDeviceStatus::NOT_PRESENT:
103 return "NOT_PRESENT";
104 case CameraDeviceStatus::PRESENT:
105 return "PRESENT";
106 case CameraDeviceStatus::ENUMERATING:
107 return "ENUMERATING";
108 }
Eino-Ville Talvalab7723202024-06-24 17:45:51 -0700109 ALOGW("Unexpected HAL device status code %d", eToI(s));
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000110 return "UNKNOWN_STATUS";
111}
112
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -0700113hardware::hidl_vec<hardware::hidl_string>
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700114CameraProviderManager::HidlServiceInteractionProxyImpl::listServices() {
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -0700115 hardware::hidl_vec<hardware::hidl_string> ret;
116 auto manager = hardware::defaultServiceManager1_2();
117 if (manager != nullptr) {
118 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
119 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
120 ret = registered;
121 });
122 }
123 return ret;
124}
125
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000126status_t CameraProviderManager::tryToInitAndAddHidlProvidersLocked(
127 HidlServiceInteractionProxy *hidlProxy) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700128 mHidlServiceProxy = hidlProxy;
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -0800129 // Registering will trigger notifications for all already-known providers
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700130 bool success = mHidlServiceProxy->registerForNotifications(
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -0800131 /* instance name, empty means no filter */ "",
132 this);
133 if (!success) {
134 ALOGE("%s: Unable to register with hardware service manager for notifications "
135 "about camera providers", __FUNCTION__);
136 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -0800137 }
Emilian Peev5d7e5152017-02-22 15:37:48 +0000138
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700139 for (const auto& instance : mHidlServiceProxy->listServices()) {
140 this->addHidlProviderLocked(instance);
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -0700141 }
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000142 return OK;
143}
144
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200145std::shared_ptr<aidl::android::hardware::camera::provider::ICameraProvider>
Avichal Rakesh682788a2024-01-11 18:01:36 -0800146CameraProviderManager::AidlServiceInteractionProxyImpl::getService(
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200147 const std::string& serviceName) {
148 using aidl::android::hardware::camera::provider::ICameraProvider;
149
150 AIBinder* binder = nullptr;
Jayant Chowdhary8e8542f2024-09-10 00:46:35 +0000151 binder = AServiceManager_waitForService(serviceName.c_str());
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200152
153 if (binder == nullptr) {
Avichal Rakesh682788a2024-01-11 18:01:36 -0800154 ALOGE("%s: AIDL Camera provider HAL '%s' is not actually available, despite waiting "
155 "indefinitely?", __FUNCTION__, serviceName.c_str());
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200156 return nullptr;
157 }
158 std::shared_ptr<ICameraProvider> interface =
159 ICameraProvider::fromBinder(ndk::SpAIBinder(binder));
160
161 return interface;
Avichal Rakesh682788a2024-01-11 18:01:36 -0800162}
163
164std::shared_ptr<aidl::android::hardware::camera::provider::ICameraProvider>
165CameraProviderManager::AidlServiceInteractionProxyImpl::tryGetService(
166 const std::string& serviceName) {
167 using aidl::android::hardware::camera::provider::ICameraProvider;
168
169 std::shared_ptr<ICameraProvider> interface = ICameraProvider::fromBinder(
170 ndk::SpAIBinder(AServiceManager_checkService(serviceName.c_str())));
171 if (interface == nullptr) {
172 ALOGD("%s: AIDL Camera provider HAL '%s' is not actually available", __FUNCTION__,
173 serviceName.c_str());
174 return nullptr;
175 }
176
177 return interface;
178}
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200179
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000180static std::string getFullAidlProviderName(const std::string instance) {
181 std::string aidlHalServiceDescriptor =
182 std::string(aidl::android::hardware::camera::provider::ICameraProvider::descriptor);
183 return aidlHalServiceDescriptor + "/" + instance;
184}
185
186status_t CameraProviderManager::tryToAddAidlProvidersLocked() {
187 const char * aidlHalServiceDescriptor =
188 aidl::android::hardware::camera::provider::ICameraProvider::descriptor;
189 auto sm = defaultServiceManager();
190 auto aidlProviders = sm->getDeclaredInstances(
191 String16(aidlHalServiceDescriptor));
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200192
193 if (isVirtualCameraHalEnabled()) {
194 // Virtual Camera provider is not declared in the VINTF manifest so we
195 // manually add it if the binary is present.
196 aidlProviders.push_back(String16(kVirtualProviderName.c_str()));
197 }
198
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000199 for (const auto &aidlInstance : aidlProviders) {
200 std::string aidlServiceName =
Austin Borger1c1bee02023-06-01 16:51:35 -0700201 getFullAidlProviderName(toStdString(aidlInstance));
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000202 auto res = sm->registerForNotifications(String16(aidlServiceName.c_str()), this);
203 if (res != OK) {
204 ALOGE("%s Unable to register for notifications with AIDL service manager",
205 __FUNCTION__);
206 return res;
207 }
Greg Kaiserae692fb2022-02-10 07:32:06 -0800208 addAidlProviderLocked(aidlServiceName);
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000209 }
210 return OK;
211}
212
213status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200214 HidlServiceInteractionProxy* hidlProxy, AidlServiceInteractionProxy* aidlProxy) {
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000215 std::lock_guard<std::mutex> lock(mInterfaceMutex);
216 if (hidlProxy == nullptr) {
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200217 ALOGE("%s: No valid service Hidl interaction proxy provided", __FUNCTION__);
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000218 return BAD_VALUE;
219 }
Vadim Caen7eccd7c2023-10-03 16:26:33 +0200220
221 if (aidlProxy == nullptr) {
222 ALOGE("%s: No valid service Aidl interaction proxy provided", __FUNCTION__);
223 return BAD_VALUE;
224 }
225 mAidlServiceProxy = aidlProxy;
226
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000227 mListener = listener;
228 mDeviceState = 0;
229 auto res = tryToInitAndAddHidlProvidersLocked(hidlProxy);
230 if (res != OK) {
231 // Logging done in called function;
232 return res;
233 }
234 res = tryToAddAidlProvidersLocked();
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800235
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700236 IPCThreadState::self()->flushCommands();
237
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000238 return res;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800239}
240
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700241std::pair<int, int> CameraProviderManager::getCameraCount() const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800242 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700243 int systemCameraCount = 0;
244 int publicCameraCount = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800245 for (auto& provider : mProviders) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700246 for (auto &id : provider->mUniqueCameraIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700247 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
248 if (getSystemCameraKindLocked(id, &deviceKind) != OK) {
249 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, id.c_str());
250 continue;
251 }
252 switch(deviceKind) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700253 case SystemCameraKind::PUBLIC:
254 publicCameraCount++;
255 break;
256 case SystemCameraKind::SYSTEM_ONLY_CAMERA:
257 systemCameraCount++;
258 break;
259 default:
260 break;
261 }
262 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800263 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700264 return std::make_pair(systemCameraCount, publicCameraCount);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800265}
266
Shuzhen Wang3d316f32022-10-25 20:33:34 +0000267std::vector<std::string> CameraProviderManager::getCameraDeviceIds(std::unordered_map<
268 std::string, std::set<std::string>>* unavailablePhysicalIds) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800269 std::lock_guard<std::mutex> lock(mInterfaceMutex);
270 std::vector<std::string> deviceIds;
271 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700272 for (auto& id : provider->mUniqueCameraIds) {
273 deviceIds.push_back(id);
Shuzhen Wang3d316f32022-10-25 20:33:34 +0000274 if (unavailablePhysicalIds != nullptr &&
275 provider->mUnavailablePhysicalCameras.count(id) > 0) {
276 (*unavailablePhysicalIds)[id] = provider->mUnavailablePhysicalCameras.at(id);
277 }
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700278 }
279 }
280 return deviceIds;
281}
282
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700283void CameraProviderManager::collectDeviceIdsLocked(const std::vector<std::string> deviceIds,
284 std::vector<std::string>& publicDeviceIds,
285 std::vector<std::string>& systemDeviceIds) const {
286 for (auto &deviceId : deviceIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700287 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
288 if (getSystemCameraKindLocked(deviceId, &deviceKind) != OK) {
289 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, deviceId.c_str());
290 continue;
291 }
292 if (deviceKind == SystemCameraKind::SYSTEM_ONLY_CAMERA) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700293 systemDeviceIds.push_back(deviceId);
294 } else {
295 publicDeviceIds.push_back(deviceId);
296 }
297 }
298}
299
Emilian Peevf53f66e2017-04-11 14:29:43 +0100300std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700301 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700302 std::vector<std::string> publicDeviceIds;
303 std::vector<std::string> systemDeviceIds;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700304 std::vector<std::string> deviceIds;
305 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700306 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700307 // Secure cameras should not be exposed through camera 1 api
308 providerDeviceIds.erase(std::remove_if(providerDeviceIds.begin(), providerDeviceIds.end(),
309 [this](const std::string& s) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700310 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
311 if (getSystemCameraKindLocked(s, &deviceKind) != OK) {
312 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, s.c_str());
313 return true;
314 }
315 return deviceKind == SystemCameraKind::HIDDEN_SECURE_CAMERA;}),
316 providerDeviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700317 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700318 // for each camera facing, only take the first id advertised by HAL in
319 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700320 filterLogicalCameraIdsLocked(providerDeviceIds);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700321 collectDeviceIdsLocked(providerDeviceIds, publicDeviceIds, systemDeviceIds);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800322 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700323 auto sortFunc =
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800324 [](const std::string& a, const std::string& b) -> bool {
325 uint32_t aUint = 0, bUint = 0;
326 bool aIsUint = base::ParseUint(a, &aUint);
327 bool bIsUint = base::ParseUint(b, &bUint);
328
329 // Uint device IDs first
330 if (aIsUint && bIsUint) {
331 return aUint < bUint;
332 } else if (aIsUint) {
333 return true;
334 } else if (bIsUint) {
335 return false;
336 }
337 // Simple string compare if both id are not uint
338 return a < b;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700339 };
340 // We put device ids for system cameras at the end since they will be pared
341 // off for processes not having system camera permissions.
342 std::sort(publicDeviceIds.begin(), publicDeviceIds.end(), sortFunc);
343 std::sort(systemDeviceIds.begin(), systemDeviceIds.end(), sortFunc);
344 deviceIds.insert(deviceIds.end(), publicDeviceIds.begin(), publicDeviceIds.end());
345 deviceIds.insert(deviceIds.end(), systemDeviceIds.begin(), systemDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800346 return deviceIds;
347}
348
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000349bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion,
350 IPCTransport transport) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800351 for (auto& provider : mProviders) {
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000352 IPCTransport providerTransport = provider->getIPCTransport();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800353 for (auto& deviceInfo : provider->mDevices) {
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000354 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion &&
355 transport == providerTransport) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800356 return true;
357 }
358 }
359 }
360 return false;
361}
362
363bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
364 std::lock_guard<std::mutex> lock(mInterfaceMutex);
365
366 auto deviceInfo = findDeviceInfoLocked(id);
367 if (deviceInfo == nullptr) return false;
368
369 return deviceInfo->hasFlashUnit();
370}
371
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800372bool CameraProviderManager::supportNativeZoomRatio(const std::string &id) const {
373 std::lock_guard<std::mutex> lock(mInterfaceMutex);
374
375 auto deviceInfo = findDeviceInfoLocked(id);
376 if (deviceInfo == nullptr) return false;
377
378 return deviceInfo->supportNativeZoomRatio();
379}
380
Emilian Peev15230142023-04-27 20:22:54 +0000381bool CameraProviderManager::isCompositeJpegRDisabled(const std::string &id) const {
Emilian Peeve579d8b2023-02-28 14:16:08 -0800382 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Emilian Peev15230142023-04-27 20:22:54 +0000383 return isCompositeJpegRDisabledLocked(id);
Emilian Peeve579d8b2023-02-28 14:16:08 -0800384}
385
Emilian Peev15230142023-04-27 20:22:54 +0000386bool CameraProviderManager::isCompositeJpegRDisabledLocked(const std::string &id) const {
Emilian Peeve579d8b2023-02-28 14:16:08 -0800387 auto deviceInfo = findDeviceInfoLocked(id);
388 if (deviceInfo == nullptr) return false;
389
Emilian Peev15230142023-04-27 20:22:54 +0000390 return deviceInfo->isCompositeJpegRDisabled();
Emilian Peeve579d8b2023-02-28 14:16:08 -0800391}
392
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800393status_t CameraProviderManager::getResourceCost(const std::string &id,
394 CameraResourceCost* cost) const {
395 std::lock_guard<std::mutex> lock(mInterfaceMutex);
396
397 auto deviceInfo = findDeviceInfoLocked(id);
398 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
399
400 *cost = deviceInfo->mResourceCost;
401 return OK;
402}
403
404status_t CameraProviderManager::getCameraInfo(const std::string &id,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000405 int rotationOverride, int *portraitRotation,
406 hardware::CameraInfo* info) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800407 std::lock_guard<std::mutex> lock(mInterfaceMutex);
408
409 auto deviceInfo = findDeviceInfoLocked(id);
410 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
411
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000412 return deviceInfo->getCameraInfo(rotationOverride, portraitRotation, info);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800413}
414
Emilian Peev35ae8262018-11-08 13:11:32 +0000415status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700416 const SessionConfiguration &configuration, bool overrideForPerfClass,
Shuzhen Wang045be6c2023-10-12 10:01:10 -0700417 bool checkSessionParams, bool *status /*out*/) const {
Emilian Peev35ae8262018-11-08 13:11:32 +0000418 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Emilian Peev35ae8262018-11-08 13:11:32 +0000419 auto deviceInfo = findDeviceInfoLocked(id);
420 if (deviceInfo == nullptr) {
421 return NAME_NOT_FOUND;
422 }
423
Shuzhen Wang141c64a2024-04-03 23:25:14 -0700424 metadataGetter getMetadata = [this](const std::string &id,
425 bool overrideForPerfClass) {
426 CameraMetadata metadata;
427 this->getCameraCharacteristicsLocked(id, overrideForPerfClass,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000428 &metadata,
429 hardware::ICameraService::ROTATION_OVERRIDE_NONE);
Shuzhen Wang141c64a2024-04-03 23:25:14 -0700430 return metadata;
431 };
Shuzhen Wanga79a64d2022-04-24 19:56:30 -0700432 return deviceInfo->isSessionConfigurationSupported(configuration,
Shuzhen Wang141c64a2024-04-03 23:25:14 -0700433 overrideForPerfClass, getMetadata, checkSessionParams, status);
Shuzhen Wang045be6c2023-10-12 10:01:10 -0700434}
435
436status_t CameraProviderManager::createDefaultRequest(const std::string& cameraId,
437 camera_request_template_t templateId,
438 CameraMetadata* metadata) const {
439 ATRACE_CALL();
440 if (templateId <= 0 || templateId >= CAMERA_TEMPLATE_COUNT) {
441 return BAD_VALUE;
442 }
443
444 std::lock_guard<std::mutex> lock(mInterfaceMutex);
445 auto deviceInfo = findDeviceInfoLocked(cameraId);
446 if (deviceInfo == nullptr) {
447 return NAME_NOT_FOUND;
448 }
449
Shuzhen Wang045be6c2023-10-12 10:01:10 -0700450 status_t res = deviceInfo->createDefaultRequest(templateId,
Shuzhen Wang33c84cd2024-01-03 17:45:03 +0000451 metadata);
Shuzhen Wang045be6c2023-10-12 10:01:10 -0700452
453 if (res == BAD_VALUE) {
454 ALOGI("%s: template %d is not supported on this camera device",
455 __FUNCTION__, templateId);
456 return res;
457 } else if (res != OK) {
458 ALOGE("Unable to construct request template %d: %s (%d)",
459 templateId, strerror(-res), res);
460 return res;
461 }
462
Shuzhen Wang045be6c2023-10-12 10:01:10 -0700463 return OK;
Emilian Peev35ae8262018-11-08 13:11:32 +0000464}
465
Avichal Rakesh3c522e22024-02-07 16:40:46 -0800466status_t CameraProviderManager::getSessionCharacteristics(
467 const std::string& id, const SessionConfiguration& configuration, bool overrideForPerfClass,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000468 int rotationOverride, CameraMetadata* sessionCharacteristics /*out*/) const {
Bharatt Kukreja6dddeb72023-11-21 10:06:25 +0000469 if (!flags::feature_combination_query()) {
470 return INVALID_OPERATION;
471 }
Avichal Rakesh3c522e22024-02-07 16:40:46 -0800472
Bharatt Kukreja6dddeb72023-11-21 10:06:25 +0000473 std::lock_guard<std::mutex> lock(mInterfaceMutex);
474 auto deviceInfo = findDeviceInfoLocked(id);
475 if (deviceInfo == nullptr) {
476 return NAME_NOT_FOUND;
477 }
478
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000479 metadataGetter getMetadata = [this, rotationOverride](const std::string& id,
Avichal Rakesh3c522e22024-02-07 16:40:46 -0800480 bool overrideForPerfClass) {
481 CameraMetadata metadata;
482 status_t ret = this->getCameraCharacteristicsLocked(id, overrideForPerfClass, &metadata,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000483 rotationOverride);
Avichal Rakesh3c522e22024-02-07 16:40:46 -0800484 if (ret != OK) {
485 ALOGE("%s: Could not get CameraCharacteristics for device %s", __FUNCTION__,
486 id.c_str());
487 }
488 return metadata;
489 };
490
Bharatt Kukreja6dddeb72023-11-21 10:06:25 +0000491 return deviceInfo->getSessionCharacteristics(configuration,
492 overrideForPerfClass, getMetadata, sessionCharacteristics);
493}
494
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800495status_t CameraProviderManager::getCameraIdIPCTransport(const std::string &id,
496 IPCTransport *providerTransport) const {
497 std::lock_guard<std::mutex> lock(mInterfaceMutex);
498 auto deviceInfo = findDeviceInfoLocked(id);
499 if (deviceInfo == nullptr) {
500 return NAME_NOT_FOUND;
501 }
502 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
503 if (parentProvider == nullptr) {
504 return DEAD_OBJECT;
505 }
506 *providerTransport = parentProvider->getIPCTransport();
507 return OK;
508}
509
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800510status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
Austin Borger18b30a72022-10-27 12:20:29 -0700511 bool overrideForPerfClass, CameraMetadata* characteristics,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000512 int rotationOverride) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800513 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Austin Borger18b30a72022-10-27 12:20:29 -0700514 return getCameraCharacteristicsLocked(id, overrideForPerfClass, characteristics,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +0000515 rotationOverride);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800516}
517
518status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000519 hardware::hidl_version *v, IPCTransport *transport) {
520 if (v == nullptr || transport == nullptr) {
521 return BAD_VALUE;
522 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800523 std::lock_guard<std::mutex> lock(mInterfaceMutex);
524
525 hardware::hidl_version maxVersion{0,0};
526 bool found = false;
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000527 IPCTransport providerTransport = IPCTransport::INVALID;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800528 for (auto& provider : mProviders) {
529 for (auto& deviceInfo : provider->mDevices) {
530 if (deviceInfo->mId == id) {
531 if (deviceInfo->mVersion > maxVersion) {
532 maxVersion = deviceInfo->mVersion;
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000533 providerTransport = provider->getIPCTransport();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800534 found = true;
535 }
536 }
537 }
538 }
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000539 if (!found || providerTransport == IPCTransport::INVALID) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800540 return NAME_NOT_FOUND;
541 }
542 *v = maxVersion;
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000543 *transport = providerTransport;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800544 return OK;
545}
546
Rucha Katakwar38284522021-11-10 11:25:21 -0800547status_t CameraProviderManager::getTorchStrengthLevel(const std::string &id,
548 int32_t* torchStrength /*out*/) {
549 std::lock_guard<std::mutex> lock(mInterfaceMutex);
550
551 auto deviceInfo = findDeviceInfoLocked(id);
552 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
553
554 return deviceInfo->getTorchStrengthLevel(torchStrength);
555}
556
557status_t CameraProviderManager::turnOnTorchWithStrengthLevel(const std::string &id,
558 int32_t torchStrength) {
559 std::lock_guard<std::mutex> lock(mInterfaceMutex);
560
561 auto deviceInfo = findDeviceInfoLocked(id);
562 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
563
564 return deviceInfo->turnOnTorchWithStrengthLevel(torchStrength);
565}
566
567bool CameraProviderManager::shouldSkipTorchStrengthUpdate(const std::string &id,
568 int32_t torchStrength) const {
569 std::lock_guard<std::mutex> lock(mInterfaceMutex);
570
571 auto deviceInfo = findDeviceInfoLocked(id);
572 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
573
574 if (deviceInfo->mTorchStrengthLevel == torchStrength) {
575 ALOGV("%s: Skipping torch strength level updates prev_level: %d, new_level: %d",
576 __FUNCTION__, deviceInfo->mTorchStrengthLevel, torchStrength);
577 return true;
578 }
579 return false;
580}
581
582int32_t CameraProviderManager::getTorchDefaultStrengthLevel(const std::string &id) const {
583 std::lock_guard<std::mutex> lock(mInterfaceMutex);
584
585 auto deviceInfo = findDeviceInfoLocked(id);
586 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
587
588 return deviceInfo->mTorchDefaultStrengthLevel;
589}
590
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700591bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700592 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700593 for (auto& provider : mProviders) {
Emilian Peevb070e1d2022-05-24 17:09:31 -0700594 for (auto& deviceInfo : provider->mDevices) {
595 if (deviceInfo->mId == id) {
596 return provider->mSetTorchModeSupported;
597 }
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700598 }
599 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700600 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700601}
602
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000603template <class ProviderInfoType, class HalCameraProviderType>
604status_t CameraProviderManager::setTorchModeT(sp<ProviderInfo> &parentProvider,
605 std::shared_ptr<HalCameraProvider> *halCameraProvider) {
606 if (halCameraProvider == nullptr) {
607 return BAD_VALUE;
608 }
609 ProviderInfoType *idlProviderInfo = static_cast<ProviderInfoType *>(parentProvider.get());
610 auto idlInterface = idlProviderInfo->startProviderInterface();
611 if (idlInterface == nullptr) {
612 return DEAD_OBJECT;
613 }
614 *halCameraProvider =
615 std::make_shared<HalCameraProviderType>(idlInterface, idlInterface->descriptor);
616 return OK;
617}
618
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800619status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
620 std::lock_guard<std::mutex> lock(mInterfaceMutex);
621
622 auto deviceInfo = findDeviceInfoLocked(id);
623 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
624
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700625 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
626 // that are currently in use.
Shuzhen Wang79680432020-03-05 11:53:46 -0800627 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
628 if (parentProvider == nullptr) {
629 return DEAD_OBJECT;
630 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700631 std::shared_ptr<HalCameraProvider> halCameraProvider = nullptr;
632 IPCTransport providerTransport = parentProvider->getIPCTransport();
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000633 status_t res = OK;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700634 if (providerTransport == IPCTransport::HIDL) {
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000635 res = setTorchModeT<HidlProviderInfo, HidlHalCameraProvider>(parentProvider,
636 &halCameraProvider);
637 if (res != OK) {
638 return res;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700639 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700640 } else if (providerTransport == IPCTransport::AIDL) {
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000641 res = setTorchModeT<AidlProviderInfo, AidlHalCameraProvider>(parentProvider,
642 &halCameraProvider);
643 if (res != OK) {
644 return res;
645 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700646 } else {
647 ALOGE("%s Invalid provider transport", __FUNCTION__);
648 return INVALID_OPERATION;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700649 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700650 saveRef(DeviceMode::TORCH, deviceInfo->mId, halCameraProvider);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700651
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800652 return deviceInfo->setTorchMode(enabled);
653}
654
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800655status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000656 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
657
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800658 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800659 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800660 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000661
662 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
663
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800664 return OK;
665}
666
Valentin Iftime29e2e152021-08-13 15:17:33 +0200667sp<CameraProviderManager::ProviderInfo> CameraProviderManager::startExternalLazyProvider() const {
668 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
669 std::lock_guard<std::mutex> lock(mInterfaceMutex);
670
671 for (const auto& providerInfo : mProviders) {
672 if (providerInfo->isExternalLazyHAL()) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700673 if (!providerInfo->successfullyStartedProviderInterface()) {
Valentin Iftime29e2e152021-08-13 15:17:33 +0200674 return nullptr;
675 } else {
676 return providerInfo;
677 }
678 }
679 }
680 return nullptr;
681}
682
683status_t CameraProviderManager::notifyUsbDeviceEvent(int32_t eventId,
684 const std::string& usbDeviceId) {
685 if (!kEnableLazyHal) {
686 return OK;
687 }
688
689 ALOGV("notifySystemEvent: %d usbDeviceId : %s", eventId, usbDeviceId.c_str());
690
691 if (eventId == android::hardware::ICameraService::EVENT_USB_DEVICE_ATTACHED) {
692 sp<ProviderInfo> externalProvider = startExternalLazyProvider();
693 if (externalProvider != nullptr) {
694 auto usbDevices = mExternalUsbDevicesForProvider.first;
695 usbDevices.push_back(usbDeviceId);
696 mExternalUsbDevicesForProvider = {usbDevices, externalProvider};
697 }
698 } else if (eventId
699 == android::hardware::ICameraService::EVENT_USB_DEVICE_DETACHED) {
700 usbDeviceDetached(usbDeviceId);
701 }
702
703 return OK;
704}
705
706status_t CameraProviderManager::usbDeviceDetached(const std::string &usbDeviceId) {
707 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
708 std::lock_guard<std::mutex> interfaceLock(mInterfaceMutex);
709
710 auto usbDevices = mExternalUsbDevicesForProvider.first;
711 auto foundId = std::find(usbDevices.begin(), usbDevices.end(), usbDeviceId);
712 if (foundId != usbDevices.end()) {
713 sp<ProviderInfo> providerInfo = mExternalUsbDevicesForProvider.second;
714 if (providerInfo == nullptr) {
715 ALOGE("%s No valid external provider for USB device: %s",
716 __FUNCTION__,
717 usbDeviceId.c_str());
718 mExternalUsbDevicesForProvider = {std::vector<std::string>(), nullptr};
719 return DEAD_OBJECT;
720 } else {
721 mInterfaceMutex.unlock();
722 providerInfo->removeAllDevices();
723 mInterfaceMutex.lock();
724 mExternalUsbDevicesForProvider = {std::vector<std::string>(), nullptr};
725 }
726 } else {
727 return DEAD_OBJECT;
728 }
729 return OK;
730}
731
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700732status_t CameraProviderManager::notifyDeviceStateChange(int64_t newState) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800733 std::lock_guard<std::mutex> lock(mInterfaceMutex);
734 mDeviceState = newState;
735 status_t res = OK;
Shuzhen Wang2e9d8fa2022-05-27 20:25:36 +0000736 // Make a copy of mProviders because we unlock mInterfaceMutex temporarily
737 // within the loop. It's possible that during the time mInterfaceMutex is
738 // unlocked, mProviders has changed.
739 auto providers = mProviders;
740 for (auto& provider : providers) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800741 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
742 __FUNCTION__, provider->mProviderName.c_str(), newState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700743 // b/199240726 Camera providers can for example try to add/remove
744 // camera devices as part of the state change notification. Holding
745 // 'mInterfaceMutex' while calling 'notifyDeviceStateChange' can
746 // result in a recursive deadlock.
747 mInterfaceMutex.unlock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800748 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
Emilian Peev7fe6c422021-09-08 13:43:20 -0700749 mInterfaceMutex.lock();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800750 if (singleRes != OK) {
751 ALOGE("%s: Unable to notify provider %s about device state change",
752 __FUNCTION__,
753 provider->mProviderName.c_str());
754 res = singleRes;
755 // continue to do the rest of the providers instead of returning now
756 }
Emilian Peevb50402e2021-09-24 17:41:57 -0700757 provider->notifyDeviceInfoStateChangeLocked(mDeviceState);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800758 }
759 return res;
760}
761
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000762status_t CameraProviderManager::openAidlSession(const std::string &id,
763 const std::shared_ptr<
764 aidl::android::hardware::camera::device::ICameraDeviceCallback>& callback,
765 /*out*/
766 std::shared_ptr<aidl::android::hardware::camera::device::ICameraDeviceSession> *session) {
767
768 std::lock_guard<std::mutex> lock(mInterfaceMutex);
769
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000770 auto deviceInfo = findDeviceInfoLocked(id);
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000771 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
772
773 auto *aidlDeviceInfo3 = static_cast<AidlProviderInfo::AidlDeviceInfo3*>(deviceInfo);
774 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
775 if (parentProvider == nullptr) {
776 return DEAD_OBJECT;
777 }
778 auto provider =
779 static_cast<AidlProviderInfo *>(parentProvider.get())->startProviderInterface();
780 if (provider == nullptr) {
781 return DEAD_OBJECT;
782 }
783 std::shared_ptr<HalCameraProvider> halCameraProvider =
784 std::make_shared<AidlHalCameraProvider>(provider, provider->descriptor);
785 saveRef(DeviceMode::CAMERA, id, halCameraProvider);
786
787 auto interface = aidlDeviceInfo3->startDeviceInterface();
788 if (interface == nullptr) {
789 removeRef(DeviceMode::CAMERA, id);
790 return DEAD_OBJECT;
791 }
792
793 auto ret = interface->open(callback, session);
794 if (!ret.isOk()) {
795 removeRef(DeviceMode::CAMERA, id);
796 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
797 __FUNCTION__, id.c_str(), ret.getMessage());
Jayant Chowdharycc3e12c2022-03-10 01:43:41 +0000798 return AidlProviderInfo::mapToStatusT(ret);
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000799 }
800 return OK;
801}
802
Jayant Chowdhary35642f22022-01-08 00:39:39 +0000803status_t CameraProviderManager::openAidlInjectionSession(const std::string &id,
804 const std::shared_ptr<
805 aidl::android::hardware::camera::device::ICameraDeviceCallback>& callback,
806 /*out*/
807 std::shared_ptr<
808 aidl::android::hardware::camera::device::ICameraInjectionSession> *session) {
809
810 std::lock_guard<std::mutex> lock(mInterfaceMutex);
811
812 auto deviceInfo = findDeviceInfoLocked(id);
813 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
814
815 auto *aidlDeviceInfo3 = static_cast<AidlProviderInfo::AidlDeviceInfo3*>(deviceInfo);
816 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
817 if (parentProvider == nullptr) {
818 return DEAD_OBJECT;
819 }
820 auto provider =
821 static_cast<AidlProviderInfo *>(parentProvider.get())->startProviderInterface();
822 if (provider == nullptr) {
823 return DEAD_OBJECT;
824 }
825 std::shared_ptr<HalCameraProvider> halCameraProvider =
826 std::make_shared<AidlHalCameraProvider>(provider, provider->descriptor);
827 saveRef(DeviceMode::CAMERA, id, halCameraProvider);
828
829 auto interface = aidlDeviceInfo3->startDeviceInterface();
830 if (interface == nullptr) {
831 return DEAD_OBJECT;
832 }
833
834 auto ret = interface->openInjectionSession(callback, session);
835 if (!ret.isOk()) {
836 removeRef(DeviceMode::CAMERA, id);
837 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
838 __FUNCTION__, id.c_str(), ret.getMessage());
839 return DEAD_OBJECT;
840 }
841 return OK;
842}
843
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700844status_t CameraProviderManager::openHidlSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800845 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800846 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800847 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800848
849 std::lock_guard<std::mutex> lock(mInterfaceMutex);
850
Jayant Chowdharyffc5d682022-05-12 18:34:34 +0000851 auto deviceInfo = findDeviceInfoLocked(id);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800852 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
853
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700854 auto *hidlDeviceInfo3 = static_cast<HidlProviderInfo::HidlDeviceInfo3*>(deviceInfo);
Shuzhen Wang79680432020-03-05 11:53:46 -0800855 sp<ProviderInfo> parentProvider = deviceInfo->mParentProvider.promote();
856 if (parentProvider == nullptr) {
857 return DEAD_OBJECT;
858 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700859 const sp<provider::V2_4::ICameraProvider> provider =
860 static_cast<HidlProviderInfo *>(parentProvider.get())->startProviderInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700861 if (provider == nullptr) {
862 return DEAD_OBJECT;
863 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700864 std::shared_ptr<HalCameraProvider> halCameraProvider =
865 std::make_shared<HidlHalCameraProvider>(provider, provider->descriptor);
866 saveRef(DeviceMode::CAMERA, id, halCameraProvider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800867
868 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700869 hardware::Return<void> ret;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700870 auto interface = hidlDeviceInfo3->startDeviceInterface();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700871 if (interface == nullptr) {
872 return DEAD_OBJECT;
873 }
874
875 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800876 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
877 status = s;
878 if (status == Status::OK) {
879 *session = cameraSession;
880 }
881 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700882 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700883 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700884 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
885 __FUNCTION__, id.c_str(), ret.description().c_str());
886 return DEAD_OBJECT;
887 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700888 return HidlProviderInfo::mapToStatusT(status);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800889}
890
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700891void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700892 std::shared_ptr<HalCameraProvider> provider) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700893 if (!kEnableLazyHal) {
894 return;
895 }
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700896 ALOGV("Saving camera provider %s for camera device %s", provider->mDescriptor.c_str(),
897 cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700898 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700899 std::unordered_map<std::string, std::shared_ptr<HalCameraProvider>> *primaryMap, *alternateMap;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700900 if (usageType == DeviceMode::TORCH) {
901 primaryMap = &mTorchProviderByCameraId;
902 alternateMap = &mCameraProviderByCameraId;
903 } else {
904 primaryMap = &mCameraProviderByCameraId;
905 alternateMap = &mTorchProviderByCameraId;
906 }
Austin Borger1c1bee02023-06-01 16:51:35 -0700907
908 (*primaryMap)[cameraId] = provider;
909 auto search = alternateMap->find(cameraId);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700910 if (search != alternateMap->end()) {
911 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
Austin Borger1c1bee02023-06-01 16:51:35 -0700912 "That should not be possible", __FUNCTION__, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700913 }
Austin Borger1c1bee02023-06-01 16:51:35 -0700914 ALOGV("%s: Camera device %s connected", __FUNCTION__, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700915}
916
917void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
918 if (!kEnableLazyHal) {
919 return;
920 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800921 ALOGV("Removing camera device %s", cameraId.c_str());
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700922 std::unordered_map<std::string, std::shared_ptr<HalCameraProvider>> *providerMap;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700923 if (usageType == DeviceMode::TORCH) {
924 providerMap = &mTorchProviderByCameraId;
925 } else {
926 providerMap = &mCameraProviderByCameraId;
927 }
928 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
Austin Borger1c1bee02023-06-01 16:51:35 -0700929 auto search = providerMap->find(cameraId);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700930 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800931 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
932 // added delay) because hwservicemanager guarantees to hold the reference for at least five
933 // more seconds. We depend on this behavior so that if the provider is unreferenced and
934 // then referenced again quickly, we do not let the HAL exit and then need to immediately
935 // restart it. An example when this could happen is switching from a front-facing to a
936 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
937 // appear janky to the user.
Austin Borger1c1bee02023-06-01 16:51:35 -0700938 providerMap->erase(cameraId);
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800939 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700940 } else {
941 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
942 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
943 cameraId.c_str());
944 }
945}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800946
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000947// We ignore sp<IBinder> param here since we need std::shared_ptr<...> which
948// will be retrieved through the ndk api through addAidlProviderLocked ->
949// tryToInitializeAidlProvider.
950void CameraProviderManager::onServiceRegistration(const String16 &name, const sp<IBinder>&) {
951 status_t res = OK;
952 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
953 {
954 std::lock_guard<std::mutex> lock(mInterfaceMutex);
955
Austin Borger1c1bee02023-06-01 16:51:35 -0700956 res = addAidlProviderLocked(toStdString(name));
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000957 }
958
959 sp<StatusListener> listener = getStatusListener();
960 if (nullptr != listener.get() && res == OK) {
961 listener->onNewProviderRegistered();
962 }
963
964 IPCThreadState::self()->flushCommands();
965}
966
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800967hardware::Return<void> CameraProviderManager::onRegistration(
968 const hardware::hidl_string& /*fqName*/,
969 const hardware::hidl_string& name,
Emilian Peevc93cac22020-08-17 16:00:10 -0700970 bool preexisting) {
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700971 status_t res = OK;
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700972 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100973 {
974 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800975
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700976 res = addHidlProviderLocked(name, preexisting);
Emilian Peevaee727d2017-05-04 16:35:48 +0100977 }
978
979 sp<StatusListener> listener = getStatusListener();
Shuzhen Wangb38b53f2021-07-15 12:46:09 -0700980 if (nullptr != listener.get() && res == OK) {
Emilian Peevaee727d2017-05-04 16:35:48 +0100981 listener->onNewProviderRegistered();
982 }
983
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700984 IPCThreadState::self()->flushCommands();
985
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800986 return hardware::Return<void>();
987}
988
989status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
990 std::lock_guard<std::mutex> lock(mInterfaceMutex);
991
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800992 for (auto& provider : mProviders) {
993 provider->dump(fd, args);
994 }
995 return OK;
996}
997
Jayant Chowdharya04055f2022-01-03 02:07:49 +0000998void CameraProviderManager::ProviderInfo::initializeProviderInfoCommon(
999 const std::vector<std::string> &devices) {
Jayant Chowdharya04055f2022-01-03 02:07:49 +00001000 for (auto& device : devices) {
1001 std::string id;
1002 status_t res = addDevice(device, CameraDeviceStatus::PRESENT, &id);
1003 if (res != OK) {
1004 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1005 __FUNCTION__, device.c_str(), strerror(-res), res);
1006 continue;
1007 }
1008 }
1009
1010 ALOGI("Camera provider %s ready with %zu camera devices",
1011 mProviderName.c_str(), mDevices.size());
1012
1013 // Process cached status callbacks
Jayant Chowdharya04055f2022-01-03 02:07:49 +00001014 {
1015 std::lock_guard<std::mutex> lock(mInitLock);
1016
1017 for (auto& statusInfo : mCachedStatus) {
1018 std::string id, physicalId;
Jayant Chowdharya04055f2022-01-03 02:07:49 +00001019 if (statusInfo.isPhysicalCameraStatus) {
Shuzhen Wang3d316f32022-10-25 20:33:34 +00001020 physicalCameraDeviceStatusChangeLocked(&id, &physicalId,
Jayant Chowdharya04055f2022-01-03 02:07:49 +00001021 statusInfo.cameraId, statusInfo.physicalCameraId, statusInfo.status);
1022 } else {
Shuzhen Wang3d316f32022-10-25 20:33:34 +00001023 cameraDeviceStatusChangeLocked(&id, statusInfo.cameraId, statusInfo.status);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00001024 }
1025 }
1026 mCachedStatus.clear();
1027
1028 mInitialized = true;
1029 }
Jayant Chowdharya04055f2022-01-03 02:07:49 +00001030}
1031
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001032CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001033 const std::string& id) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001034 for (auto& provider : mProviders) {
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001035 using hardware::hidl_version;
1036 IPCTransport transport = provider->getIPCTransport();
1037 // AIDL min version starts at major: 1 minor: 1
1038 hidl_version minVersion =
1039 (transport == IPCTransport::HIDL) ? hidl_version{3, 2} : hidl_version{1, 1} ;
1040 hidl_version maxVersion =
1041 (transport == IPCTransport::HIDL) ? hidl_version{3, 7} : hidl_version{1000, 0};
1042
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001043 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -08001044 if (deviceInfo->mId == id &&
1045 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001046 return deviceInfo.get();
1047 }
1048 }
1049 }
1050 return nullptr;
1051}
1052
Emilian Peev71c73a22017-03-21 16:35:51 +00001053metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001054 const std::string& id) const {
Emilian Peev71c73a22017-03-21 16:35:51 +00001055 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
1056
1057 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1058 for (auto& provider : mProviders) {
1059 for (auto& deviceInfo : provider->mDevices) {
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001060 if (deviceInfo->mId == id) {
Emilian Peev71c73a22017-03-21 16:35:51 +00001061 return provider->mProviderTagid;
1062 }
1063 }
1064 }
1065
1066 return ret;
1067}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001068
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001069void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
1070 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001071
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001072 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001073 for (size_t i = 0; i < entryCap.count; ++i) {
1074 uint8_t capability = entryCap.data.u8[i];
1075 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001076 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001077 break;
1078 }
1079 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001080 if (!mIsLogicalCamera) {
1081 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001082 }
1083
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001084 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
1085 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001086 const uint8_t* ids = entryIds.data.u8;
1087 size_t start = 0;
1088 for (size_t i = 0; i < entryIds.count; ++i) {
1089 if (ids[i] == '\0') {
1090 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001091 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001092 }
1093 start = i+1;
1094 }
1095 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001096}
1097
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001098SystemCameraKind CameraProviderManager::ProviderInfo::DeviceInfo3::getSystemCameraKind() {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001099 camera_metadata_entry_t entryCap;
1100 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001101 if (entryCap.count == 1 &&
1102 entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
1103 return SystemCameraKind::HIDDEN_SECURE_CAMERA;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001104 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001105
1106 // Go through the capabilities and check if it has
1107 // ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA
1108 for (size_t i = 0; i < entryCap.count; ++i) {
1109 uint8_t capability = entryCap.data.u8[i];
1110 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA) {
1111 return SystemCameraKind::SYSTEM_ONLY_CAMERA;
1112 }
1113 }
1114 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001115}
1116
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001117void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
1118 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
1119 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
1120 if (sizes == nullptr) {
1121 return;
1122 }
1123
1124 auto scalerDims = ch.find(tag);
1125 if (scalerDims.count > 0) {
1126 // Scaler entry contains 4 elements (format, width, height, type)
1127 for (size_t i = 0; i < scalerDims.count; i += 4) {
1128 if ((scalerDims.data.i32[i] == format) &&
1129 (scalerDims.data.i32[i+3] ==
1130 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
1131 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
1132 scalerDims.data.i32[i+2]));
1133 }
1134 }
1135 }
1136}
1137
1138void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
1139 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
1140 const std::vector<std::tuple<size_t, size_t>>& sizes,
1141 std::vector<int64_t> *durations/*out*/) {
1142 if (durations == nullptr) {
1143 return;
1144 }
1145
1146 auto availableDurations = ch.find(tag);
1147 if (availableDurations.count > 0) {
1148 // Duration entry contains 4 elements (format, width, height, duration)
Euisang Limff49bdb2023-02-13 19:54:53 +09001149 for (const auto& size : sizes) {
1150 int64_t width = std::get<0>(size);
1151 int64_t height = std::get<1>(size);
1152 for (size_t i = 0; i < availableDurations.count; i += 4) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001153 if ((availableDurations.data.i64[i] == format) &&
1154 (availableDurations.data.i64[i+1] == width) &&
1155 (availableDurations.data.i64[i+2] == height)) {
1156 durations->push_back(availableDurations.data.i64[i+3]);
Euisang Limff49bdb2023-02-13 19:54:53 +09001157 break;
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001158 }
1159 }
1160 }
1161 }
1162}
Euisang Limff49bdb2023-02-13 19:54:53 +09001163
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001164void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
1165 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
1166 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
1167 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
1168 return;
1169 }
1170
1171 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
1172 // Processing time on camera service side can vary greatly depending on multiple
1173 // variables which are not under our control. Make a guesstimate by taking the maximum
1174 // corresponding duration value from depth and blob.
1175 auto depthDuration = depthDurations.begin();
1176 auto blobDuration = blobDurations.begin();
1177 dynamicDepthDurations->reserve(depthDurations.size());
1178 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
1179 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
1180 depthDuration++; blobDuration++;
1181 }
1182}
1183
1184void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
1185 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
1186 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
1187 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
1188 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
1189 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
1190 return;
1191 }
1192
1193 // The dynamic depth spec. does not mention how close the AR ratio should be.
1194 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +00001195 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001196
1197 for (const auto& blobSize : blobSizes) {
1198 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
1199 static_cast<float>(std::get<1>(blobSize));
1200 bool found = false;
1201 for (const auto& depthSize : depthSizes) {
1202 if (depthSize == blobSize) {
1203 internalDepthSizes->push_back(depthSize);
1204 found = true;
1205 break;
1206 } else {
1207 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
1208 static_cast<float>(std::get<1>(depthSize));
1209 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
1210 internalDepthSizes->push_back(depthSize);
1211 found = true;
1212 break;
1213 }
1214 }
1215 }
1216
1217 if (found) {
1218 dynamicDepthSizes->push_back(blobSize);
1219 }
1220 }
1221}
1222
Emilian Peev434248e2022-10-06 14:58:54 -07001223bool CameraProviderManager::isConcurrentDynamicRangeCaptureSupported(
1224 const CameraMetadata& deviceInfo, int64_t profile, int64_t concurrentProfile) {
1225 auto entry = deviceInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1226 if (entry.count == 0) {
1227 return false;
1228 }
1229
1230 const auto it = std::find(entry.data.u8, entry.data.u8 + entry.count,
1231 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT);
1232 if (it == entry.data.u8 + entry.count) {
1233 return false;
1234 }
1235
1236 entry = deviceInfo.find(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP);
1237 if (entry.count == 0 || ((entry.count % 3) != 0)) {
1238 return false;
1239 }
1240
1241 for (size_t i = 0; i < entry.count; i += 3) {
1242 if (entry.data.i64[i] == profile) {
Emilian Peev6a66d992023-04-19 18:12:01 -07001243 if ((entry.data.i64[i+1] == 0) || (entry.data.i64[i+1] & concurrentProfile)) {
Emilian Peev434248e2022-10-06 14:58:54 -07001244 return true;
1245 }
1246 }
1247 }
1248
1249 return false;
1250}
1251
1252status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveJpegRTags(bool maxResolution) {
Emilian Peev15230142023-04-27 20:22:54 +00001253 if (kFrameworkJpegRDisabled || mCompositeJpegRDisabled) {
Emilian Peev434248e2022-10-06 14:58:54 -07001254 return OK;
1255 }
1256
1257 const int32_t scalerSizesTag =
1258 SessionConfigurationUtils::getAppropriateModeTag(
1259 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
Emilian Peevbf1565b2023-06-06 13:36:58 -07001260 const int32_t scalerMinFrameDurationsTag = SessionConfigurationUtils::getAppropriateModeTag(
1261 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, maxResolution);
Emilian Peev434248e2022-10-06 14:58:54 -07001262 const int32_t scalerStallDurationsTag =
1263 SessionConfigurationUtils::getAppropriateModeTag(
1264 ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, maxResolution);
1265
1266 const int32_t jpegRSizesTag =
1267 SessionConfigurationUtils::getAppropriateModeTag(
1268 ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS, maxResolution);
1269 const int32_t jpegRStallDurationsTag =
1270 SessionConfigurationUtils::getAppropriateModeTag(
1271 ANDROID_JPEGR_AVAILABLE_JPEG_R_STALL_DURATIONS, maxResolution);
1272 const int32_t jpegRMinFrameDurationsTag =
1273 SessionConfigurationUtils::getAppropriateModeTag(
1274 ANDROID_JPEGR_AVAILABLE_JPEG_R_MIN_FRAME_DURATIONS, maxResolution);
1275
1276 auto& c = mCameraCharacteristics;
1277 std::vector<int32_t> supportedChTags;
1278 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1279 if (chTags.count == 0) {
1280 ALOGE("%s: No supported camera characteristics keys!", __FUNCTION__);
1281 return BAD_VALUE;
1282 }
1283
Euisang Limff49bdb2023-02-13 19:54:53 +09001284 std::vector<std::tuple<size_t, size_t>> supportedP010Sizes, supportedBlobSizes;
Emilian Peev434248e2022-10-06 14:58:54 -07001285 auto capabilities = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1286 if (capabilities.count == 0) {
1287 ALOGE("%s: Supported camera capabilities is empty!", __FUNCTION__);
1288 return BAD_VALUE;
1289 }
1290
1291 auto end = capabilities.data.u8 + capabilities.count;
1292 bool isTenBitOutputSupported = std::find(capabilities.data.u8, end,
1293 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT) != end;
1294 if (!isTenBitOutputSupported) {
1295 // No 10-bit support, nothing more to do.
1296 return OK;
1297 }
1298
Emilian Peev15230142023-04-27 20:22:54 +00001299 if (!isConcurrentDynamicRangeCaptureSupported(c,
1300 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_HLG10,
1301 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD) &&
1302 !property_get_bool("ro.camera.enableCompositeAPI0JpegR", false)) {
1303 // API0, P010 only Jpeg/R support is meant to be used only as a reference due to possible
1304 // impact on quality and performance.
1305 // This data path will be turned off by default and individual device builds must enable
1306 // 'ro.camera.enableCompositeAPI0JpegR' in order to experiment using it.
1307 mCompositeJpegRDisabled = true;
1308 return OK;
1309 }
1310
Emilian Peev434248e2022-10-06 14:58:54 -07001311 getSupportedSizes(c, scalerSizesTag,
1312 static_cast<android_pixel_format_t>(HAL_PIXEL_FORMAT_BLOB), &supportedBlobSizes);
1313 getSupportedSizes(c, scalerSizesTag,
1314 static_cast<android_pixel_format_t>(HAL_PIXEL_FORMAT_YCBCR_P010), &supportedP010Sizes);
1315 auto it = supportedP010Sizes.begin();
1316 while (it != supportedP010Sizes.end()) {
Emilian Peevbbfff9c2023-02-02 14:01:14 -08001317 if (std::find(supportedBlobSizes.begin(), supportedBlobSizes.end(), *it) ==
1318 supportedBlobSizes.end()) {
Emilian Peev434248e2022-10-06 14:58:54 -07001319 it = supportedP010Sizes.erase(it);
1320 } else {
1321 it++;
1322 }
1323 }
1324 if (supportedP010Sizes.empty()) {
1325 // Nothing to do in this case.
1326 return OK;
1327 }
1328
1329 std::vector<int32_t> jpegREntries;
1330 for (const auto& it : supportedP010Sizes) {
1331 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
1332 static_cast<int32_t> (std::get<1>(it)),
1333 ANDROID_JPEGR_AVAILABLE_JPEG_R_STREAM_CONFIGURATIONS_OUTPUT };
1334 jpegREntries.insert(jpegREntries.end(), entry, entry + 4);
1335 }
1336
1337 std::vector<int64_t> blobMinDurations, blobStallDurations;
1338 std::vector<int64_t> jpegRMinDurations, jpegRStallDurations;
1339
1340 // We use the jpeg stall and min frame durations to approximate the respective jpeg/r
1341 // durations.
1342 getSupportedDurations(c, scalerMinFrameDurationsTag, HAL_PIXEL_FORMAT_BLOB,
1343 supportedP010Sizes, &blobMinDurations);
1344 getSupportedDurations(c, scalerStallDurationsTag, HAL_PIXEL_FORMAT_BLOB,
1345 supportedP010Sizes, &blobStallDurations);
1346 if (blobStallDurations.empty() || blobMinDurations.empty() ||
Euisang Limff49bdb2023-02-13 19:54:53 +09001347 supportedP010Sizes.size() != blobMinDurations.size() ||
1348 blobMinDurations.size() != blobStallDurations.size()) {
1349 ALOGE("%s: Unexpected number of available blob durations! %zu vs. %zu with "
1350 "supportedP010Sizes size: %zu", __FUNCTION__, blobMinDurations.size(),
1351 blobStallDurations.size(), supportedP010Sizes.size());
Emilian Peev434248e2022-10-06 14:58:54 -07001352 return BAD_VALUE;
1353 }
1354
1355 auto itDuration = blobMinDurations.begin();
1356 auto itSize = supportedP010Sizes.begin();
1357 while (itDuration != blobMinDurations.end()) {
1358 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
1359 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
1360 jpegRMinDurations.insert(jpegRMinDurations.end(), entry, entry + 4);
1361 itDuration++; itSize++;
1362 }
1363
1364 itDuration = blobStallDurations.begin();
1365 itSize = supportedP010Sizes.begin();
1366 while (itDuration != blobStallDurations.end()) {
1367 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
1368 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
1369 jpegRStallDurations.insert(jpegRStallDurations.end(), entry, entry + 4);
1370 itDuration++; itSize++;
1371 }
1372
1373 supportedChTags.reserve(chTags.count + 3);
1374 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
1375 chTags.data.i32 + chTags.count);
1376 supportedChTags.push_back(jpegRSizesTag);
1377 supportedChTags.push_back(jpegRMinFrameDurationsTag);
1378 supportedChTags.push_back(jpegRStallDurationsTag);
1379 c.update(jpegRSizesTag, jpegREntries.data(), jpegREntries.size());
1380 c.update(jpegRMinFrameDurationsTag, jpegRMinDurations.data(), jpegRMinDurations.size());
1381 c.update(jpegRStallDurationsTag, jpegRStallDurations.data(), jpegRStallDurations.size());
1382 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
1383 supportedChTags.size());
1384
1385 auto colorSpaces = c.find(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP);
1386 if (colorSpaces.count > 0 && !maxResolution) {
1387 bool displayP3Support = false;
1388 int64_t dynamicRange = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
1389 for (size_t i = 0; i < colorSpaces.count; i += 3) {
1390 auto colorSpace = colorSpaces.data.i64[i];
1391 auto format = colorSpaces.data.i64[i+1];
1392 bool formatMatch = (format == static_cast<int64_t>(PublicFormat::JPEG)) ||
1393 (format == static_cast<int64_t>(PublicFormat::UNKNOWN));
1394 bool colorSpaceMatch =
1395 colorSpace == ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3;
1396 if (formatMatch && colorSpaceMatch) {
1397 displayP3Support = true;
1398 }
1399
1400 // Jpeg/R will support the same dynamic range profiles as P010
1401 if (format == static_cast<int64_t>(PublicFormat::YCBCR_P010)) {
1402 dynamicRange |= colorSpaces.data.i64[i+2];
1403 }
1404 }
1405 if (displayP3Support) {
1406 std::vector<int64_t> supportedColorSpaces;
1407 // Jpeg/R must support the default system as well ase display P3 color space
1408 supportedColorSpaces.reserve(colorSpaces.count + 3*2);
1409 supportedColorSpaces.insert(supportedColorSpaces.end(), colorSpaces.data.i64,
1410 colorSpaces.data.i64 + colorSpaces.count);
1411
1412 supportedColorSpaces.push_back(static_cast<int64_t>(
1413 ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_SRGB));
1414 supportedColorSpaces.push_back(static_cast<int64_t>(PublicFormat::JPEG_R));
1415 supportedColorSpaces.push_back(dynamicRange);
1416
1417 supportedColorSpaces.push_back(static_cast<int64_t>(
1418 ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_DISPLAY_P3));
1419 supportedColorSpaces.push_back(static_cast<int64_t>(PublicFormat::JPEG_R));
1420 supportedColorSpaces.push_back(dynamicRange);
1421 c.update(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP,
1422 supportedColorSpaces.data(), supportedColorSpaces.size());
1423 }
1424 }
1425
1426 return OK;
1427}
1428
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001429status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags(
1430 bool maxResolution) {
1431 const int32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
1432
1433 const int32_t scalerSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001434 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001435 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
1436 const int32_t scalerMinFrameDurationsTag =
1437 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
1438 const int32_t scalerStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001439 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001440 ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, maxResolution);
1441
1442 const int32_t depthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001443 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001444 ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
1445 const int32_t depthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001446 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001447 ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, maxResolution);
1448 const int32_t depthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001449 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001450 ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
1451
1452 const int32_t dynamicDepthSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001453 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001454 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS, maxResolution);
1455 const int32_t dynamicDepthStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001456 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001457 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS, maxResolution);
1458 const int32_t dynamicDepthMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001459 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001460 ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS, maxResolution);
1461
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001462 auto& c = mCameraCharacteristics;
1463 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
1464 supportedDynamicDepthSizes, internalDepthSizes;
1465 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1466 if (chTags.count == 0) {
1467 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
1468 return BAD_VALUE;
1469 }
1470
1471 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
1472 depthExclTag) != (chTags.data.i32 + chTags.count);
1473 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -08001474 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001475 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
1476 // No depth support, nothing more to do.
1477 return OK;
1478 }
1479
1480 auto depthExclusiveEntry = c.find(depthExclTag);
1481 if (depthExclusiveEntry.count > 0) {
1482 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
1483 // Depth support is exclusive, nothing more to do.
1484 return OK;
1485 }
1486 } else {
1487 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
1488 return BAD_VALUE;
1489 }
1490
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001491 getSupportedSizes(c, scalerSizesTag, HAL_PIXEL_FORMAT_BLOB,
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001492 &supportedBlobSizes);
1493 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
1494 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
1495 // Nothing to do in this case.
1496 return OK;
1497 }
1498
1499 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
1500 &supportedDynamicDepthSizes, &internalDepthSizes);
1501 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001502 // Nothing more to do.
1503 return OK;
1504 }
1505
1506 std::vector<int32_t> dynamicDepthEntries;
1507 for (const auto& it : supportedDynamicDepthSizes) {
1508 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
1509 static_cast<int32_t> (std::get<1>(it)),
1510 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
1511 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
1512 }
1513
1514 std::vector<int64_t> depthMinDurations, depthStallDurations;
1515 std::vector<int64_t> blobMinDurations, blobStallDurations;
1516 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
1517
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001518 getSupportedDurations(c, depthMinFrameDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
1519 &depthMinDurations);
1520 getSupportedDurations(c, scalerMinFrameDurationsTag, HAL_PIXEL_FORMAT_BLOB,
1521 supportedDynamicDepthSizes, &blobMinDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001522 if (blobMinDurations.empty() || depthMinDurations.empty() ||
1523 (depthMinDurations.size() != blobMinDurations.size())) {
1524 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
1525 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
1526 return BAD_VALUE;
1527 }
1528
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001529 getSupportedDurations(c, depthStallDurationsTag, HAL_PIXEL_FORMAT_Y16, internalDepthSizes,
1530 &depthStallDurations);
1531 getSupportedDurations(c, scalerStallDurationsTag, HAL_PIXEL_FORMAT_BLOB,
1532 supportedDynamicDepthSizes, &blobStallDurations);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001533 if (blobStallDurations.empty() || depthStallDurations.empty() ||
1534 (depthStallDurations.size() != blobStallDurations.size())) {
1535 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
1536 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
1537 return BAD_VALUE;
1538 }
1539
1540 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
1541 &dynamicDepthMinDurations);
1542 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
1543 &dynamicDepthStallDurations);
1544 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
1545 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
1546 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
1547 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
1548 return BAD_VALUE;
1549 }
1550
1551 std::vector<int64_t> dynamicDepthMinDurationEntries;
1552 auto itDuration = dynamicDepthMinDurations.begin();
1553 auto itSize = supportedDynamicDepthSizes.begin();
1554 while (itDuration != dynamicDepthMinDurations.end()) {
1555 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
1556 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
1557 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
1558 entry + 4);
1559 itDuration++; itSize++;
1560 }
1561
1562 std::vector<int64_t> dynamicDepthStallDurationEntries;
1563 itDuration = dynamicDepthStallDurations.begin();
1564 itSize = supportedDynamicDepthSizes.begin();
1565 while (itDuration != dynamicDepthStallDurations.end()) {
1566 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
1567 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
1568 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
1569 entry + 4);
1570 itDuration++; itSize++;
1571 }
1572
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001573 std::vector<int32_t> supportedChTags;
1574 supportedChTags.reserve(chTags.count + 3);
1575 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
1576 chTags.data.i32 + chTags.count);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001577 supportedChTags.push_back(dynamicDepthSizesTag);
1578 supportedChTags.push_back(dynamicDepthMinFrameDurationsTag);
1579 supportedChTags.push_back(dynamicDepthStallDurationsTag);
1580 c.update(dynamicDepthSizesTag, dynamicDepthEntries.data(), dynamicDepthEntries.size());
1581 c.update(dynamicDepthMinFrameDurationsTag, dynamicDepthMinDurationEntries.data(),
1582 dynamicDepthMinDurationEntries.size());
1583 c.update(dynamicDepthStallDurationsTag, dynamicDepthStallDurationEntries.data(),
1584 dynamicDepthStallDurationEntries.size());
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001585 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
1586 supportedChTags.size());
1587
1588 return OK;
1589}
1590
Rucha Katakwar31fbf3a2022-05-02 13:23:56 -07001591status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupTorchStrengthTags() {
1592 status_t res = OK;
1593 auto& c = mCameraCharacteristics;
1594 auto flashInfoStrengthDefaultLevelEntry = c.find(ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL);
1595 if (flashInfoStrengthDefaultLevelEntry.count == 0) {
1596 int32_t flashInfoStrengthDefaultLevel = 1;
1597 res = c.update(ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL,
1598 &flashInfoStrengthDefaultLevel, 1);
1599 if (res != OK) {
1600 ALOGE("%s: Failed to update ANDROID_FLASH_INFO_STRENGTH_DEFAULT_LEVEL: %s (%d)",
1601 __FUNCTION__,strerror(-res), res);
1602 return res;
1603 }
1604 }
1605 auto flashInfoStrengthMaximumLevelEntry = c.find(ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL);
1606 if (flashInfoStrengthMaximumLevelEntry.count == 0) {
1607 int32_t flashInfoStrengthMaximumLevel = 1;
1608 res = c.update(ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL,
1609 &flashInfoStrengthMaximumLevel, 1);
1610 if (res != OK) {
1611 ALOGE("%s: Failed to update ANDROID_FLASH_INFO_STRENGTH_MAXIMUM_LEVEL: %s (%d)",
1612 __FUNCTION__,strerror(-res), res);
1613 return res;
1614 }
1615 }
1616 return res;
1617}
1618
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001619
1620status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupManualFlashStrengthControlTags(
1621 CameraMetadata& ch) {
Rucha Katakward0dc8032023-09-26 15:39:31 -07001622 status_t res = OK;
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001623 auto flashSingleStrengthMaxLevelEntry = ch.find(ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL);
Rucha Katakward0dc8032023-09-26 15:39:31 -07001624 if (flashSingleStrengthMaxLevelEntry.count == 0) {
1625 int32_t flashSingleStrengthMaxLevel = 1;
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001626 res = ch.update(ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL,
Rucha Katakward0dc8032023-09-26 15:39:31 -07001627 &flashSingleStrengthMaxLevel, 1);
1628 if (res != OK) {
1629 ALOGE("%s: Failed to update ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL: %s (%d)",
1630 __FUNCTION__,strerror(-res), res);
1631 return res;
1632 }
1633 }
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001634 auto flashSingleStrengthDefaultLevelEntry = ch.find(
1635 ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL);
Rucha Katakward0dc8032023-09-26 15:39:31 -07001636 if (flashSingleStrengthDefaultLevelEntry.count == 0) {
1637 int32_t flashSingleStrengthDefaultLevel = 1;
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001638 res = ch.update(ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL,
Rucha Katakward0dc8032023-09-26 15:39:31 -07001639 &flashSingleStrengthDefaultLevel, 1);
1640 if (res != OK) {
1641 ALOGE("%s: Failed to update ANDROID_FLASH_SINGLE_STRENGTH_DEFAULT_LEVEL: %s (%d)",
1642 __FUNCTION__,strerror(-res), res);
1643 return res;
1644 }
1645 }
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001646 auto flashTorchStrengthMaxLevelEntry = ch.find(ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL);
Rucha Katakward0dc8032023-09-26 15:39:31 -07001647 if (flashTorchStrengthMaxLevelEntry.count == 0) {
1648 int32_t flashTorchStrengthMaxLevel = 1;
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001649 res = ch.update(ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL,
Rucha Katakward0dc8032023-09-26 15:39:31 -07001650 &flashTorchStrengthMaxLevel, 1);
1651 if (res != OK) {
1652 ALOGE("%s: Failed to update ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL: %s (%d)",
1653 __FUNCTION__,strerror(-res), res);
1654 return res;
1655 }
1656 }
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001657 auto flashTorchStrengthDefaultLevelEntry = ch.find(ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL);
Rucha Katakward0dc8032023-09-26 15:39:31 -07001658 if (flashTorchStrengthDefaultLevelEntry.count == 0) {
1659 int32_t flashTorchStrengthDefaultLevel = 1;
Rucha Katakware4d3e1f2023-11-06 13:46:45 -08001660 res = ch.update(ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL,
Rucha Katakward0dc8032023-09-26 15:39:31 -07001661 &flashTorchStrengthDefaultLevel, 1);
1662 if (res != OK) {
1663 ALOGE("%s: Failed to update ANDROID_FLASH_TORCH_STRENGTH_DEFAULT_LEVEL: %s (%d)",
1664 __FUNCTION__,strerror(-res), res);
1665 return res;
1666 }
1667 }
1668 return res;
1669}
1670
Shuzhen Wang268a1362018-10-16 16:32:59 -07001671status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
1672 status_t res = OK;
1673 auto& c = mCameraCharacteristics;
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001674 sp<ProviderInfo> parentProvider = mParentProvider.promote();
1675 if (parentProvider == nullptr) {
1676 return DEAD_OBJECT;
1677 }
1678 IPCTransport ipcTransport = parentProvider->getIPCTransport();
Shuzhen Wang268a1362018-10-16 16:32:59 -07001679 // Override static metadata for MONOCHROME camera with older device version
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001680 if (ipcTransport == IPCTransport::HIDL &&
1681 (mVersion.get_major() == 3 && mVersion.get_minor() < 5)) {
Shuzhen Wang268a1362018-10-16 16:32:59 -07001682 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1683 for (size_t i = 0; i < cap.count; i++) {
1684 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
1685 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
1686 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
1687 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
1688 if (res != OK) {
1689 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
1690 __FUNCTION__, strerror(-res), res);
1691 return res;
1692 }
1693
1694 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
1695 const std::vector<uint32_t> sKeys = {
1696 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
1697 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
1698 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
1699 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
1700 ANDROID_SENSOR_COLOR_TRANSFORM1,
1701 ANDROID_SENSOR_COLOR_TRANSFORM2,
1702 ANDROID_SENSOR_FORWARD_MATRIX1,
1703 ANDROID_SENSOR_FORWARD_MATRIX2,
1704 };
1705 res = removeAvailableKeys(c, sKeys,
1706 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1707 if (res != OK) {
1708 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
1709 __FUNCTION__, strerror(-res), res);
1710 return res;
1711 }
1712
1713 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
1714 const std::vector<uint32_t> reqKeys = {
1715 ANDROID_COLOR_CORRECTION_MODE,
1716 ANDROID_COLOR_CORRECTION_TRANSFORM,
1717 ANDROID_COLOR_CORRECTION_GAINS,
1718 };
1719 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
1720 if (res != OK) {
1721 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
1722 __FUNCTION__, strerror(-res), res);
1723 return res;
1724 }
1725
1726 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
1727 const std::vector<uint32_t> resKeys = {
1728 ANDROID_SENSOR_GREEN_SPLIT,
1729 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
1730 ANDROID_COLOR_CORRECTION_MODE,
1731 ANDROID_COLOR_CORRECTION_TRANSFORM,
1732 ANDROID_COLOR_CORRECTION_GAINS,
1733 };
1734 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
1735 if (res != OK) {
1736 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
1737 __FUNCTION__, strerror(-res), res);
1738 return res;
1739 }
1740
1741 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
1742 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
1743 for (size_t j = 1; j < blEntry.count; j++) {
1744 blEntry.data.i32[j] = blEntry.data.i32[0];
1745 }
1746 }
1747 }
1748 }
1749 return res;
1750}
1751
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001752status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addRotateCropTags() {
1753 status_t res = OK;
1754 auto& c = mCameraCharacteristics;
1755
1756 auto availableRotateCropEntry = c.find(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES);
1757 if (availableRotateCropEntry.count == 0) {
1758 uint8_t defaultAvailableRotateCropEntry = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
1759 res = c.update(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES,
1760 &defaultAvailableRotateCropEntry, 1);
1761 }
1762 return res;
1763}
1764
Bharatt Kukrejad33fe9f2022-11-23 21:52:52 +00001765status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addAutoframingTags() {
1766 status_t res = OK;
1767 auto& c = mCameraCharacteristics;
1768
1769 auto availableAutoframingEntry = c.find(ANDROID_CONTROL_AUTOFRAMING_AVAILABLE);
1770 if (availableAutoframingEntry.count == 0) {
1771 uint8_t defaultAutoframingEntry = ANDROID_CONTROL_AUTOFRAMING_AVAILABLE_FALSE;
1772 res = c.update(ANDROID_CONTROL_AUTOFRAMING_AVAILABLE,
1773 &defaultAutoframingEntry, 1);
1774 }
1775 return res;
1776}
1777
Shuzhen Wang9bf8a6f2020-05-01 09:49:04 -07001778status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addPreCorrectionActiveArraySize() {
1779 status_t res = OK;
1780 auto& c = mCameraCharacteristics;
1781
1782 auto activeArraySize = c.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
1783 auto preCorrectionActiveArraySize = c.find(
1784 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
1785 if (activeArraySize.count == 4 && preCorrectionActiveArraySize.count == 0) {
1786 std::vector<int32_t> preCorrectionArray(
1787 activeArraySize.data.i32, activeArraySize.data.i32+4);
1788 res = c.update(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE,
1789 preCorrectionArray.data(), 4);
1790 if (res != OK) {
1791 ALOGE("%s: Failed to add ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE: %s(%d)",
1792 __FUNCTION__, strerror(-res), res);
1793 return res;
1794 }
1795 } else {
1796 return res;
1797 }
1798
1799 auto charTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
1800 bool hasPreCorrectionActiveArraySize = std::find(charTags.data.i32,
1801 charTags.data.i32 + charTags.count,
1802 ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE) !=
1803 (charTags.data.i32 + charTags.count);
1804 if (!hasPreCorrectionActiveArraySize) {
1805 std::vector<int32_t> supportedCharTags;
1806 supportedCharTags.reserve(charTags.count + 1);
1807 supportedCharTags.insert(supportedCharTags.end(), charTags.data.i32,
1808 charTags.data.i32 + charTags.count);
1809 supportedCharTags.push_back(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
1810
1811 res = c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedCharTags.data(),
1812 supportedCharTags.size());
1813 if (res != OK) {
1814 ALOGE("%s: Failed to update ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s(%d)",
1815 __FUNCTION__, strerror(-res), res);
1816 return res;
1817 }
1818 }
1819
1820 return res;
1821}
1822
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001823status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addReadoutTimestampTag(
1824 bool readoutTimestampSupported) {
Shuzhen Wangffc4c012022-04-20 15:55:46 -07001825 status_t res = OK;
1826 auto& c = mCameraCharacteristics;
1827
1828 auto entry = c.find(ANDROID_SENSOR_READOUT_TIMESTAMP);
Avichal Rakeshd6b51642023-12-13 12:50:35 -08001829 if (entry.count == 0) {
1830 uint8_t defaultReadoutTimestamp = readoutTimestampSupported ?
1831 ANDROID_SENSOR_READOUT_TIMESTAMP_HARDWARE :
1832 ANDROID_SENSOR_READOUT_TIMESTAMP_NOT_SUPPORTED;
1833 res = c.update(ANDROID_SENSOR_READOUT_TIMESTAMP, &defaultReadoutTimestamp, 1);
Shuzhen Wangffc4c012022-04-20 15:55:46 -07001834 }
1835
Shuzhen Wangffc4c012022-04-20 15:55:46 -07001836 return res;
1837}
1838
Shuzhen Wang045be6c2023-10-12 10:01:10 -07001839status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addSessionConfigQueryVersionTag() {
1840 sp<ProviderInfo> parentProvider = mParentProvider.promote();
1841 if (parentProvider == nullptr) {
1842 return DEAD_OBJECT;
1843 }
1844
1845 int versionCode = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_UPSIDE_DOWN_CAKE;
1846 IPCTransport ipcTransport = parentProvider->getIPCTransport();
1847 int deviceVersion = HARDWARE_DEVICE_API_VERSION(mVersion.get_major(), mVersion.get_minor());
1848 if (ipcTransport == IPCTransport::AIDL
1849 && deviceVersion >= CAMERA_DEVICE_API_VERSION_1_3) {
1850 versionCode = ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION_VANILLA_ICE_CREAM;
1851 }
1852
1853 auto& c = mCameraCharacteristics;
1854 status_t res = c.update(ANDROID_INFO_SESSION_CONFIGURATION_QUERY_VERSION, &versionCode, 1);
Avichal Rakesh4baf7262024-03-20 19:16:04 -07001855 mSessionConfigQueryVersion = versionCode;
Shuzhen Wang045be6c2023-10-12 10:01:10 -07001856 return res;
1857}
1858
Shuzhen Wang268a1362018-10-16 16:32:59 -07001859status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
1860 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
1861 status_t res = OK;
1862
1863 camera_metadata_entry keysEntry = c.find(keyTag);
1864 if (keysEntry.count == 0) {
1865 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
1866 return res;
1867 }
1868 std::vector<int32_t> vKeys;
1869 vKeys.reserve(keysEntry.count);
1870 for (size_t i = 0; i < keysEntry.count; i++) {
1871 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
1872 vKeys.push_back(keysEntry.data.i32[i]);
1873 }
1874 }
1875 res = c.update(keyTag, vKeys.data(), vKeys.size());
1876 return res;
1877}
1878
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001879status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
1880 std::vector<int32_t>* outputs,
1881 std::vector<int64_t>* durations,
1882 std::vector<int64_t>* stallDurations,
1883 const camera_metadata_entry& halStreamConfigs,
1884 const camera_metadata_entry& halStreamDurations) {
1885 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
1886 return BAD_VALUE;
1887 }
1888
1889 static bool supportInMemoryTempFile =
1890 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
1891 if (!supportInMemoryTempFile) {
1892 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
1893 __FUNCTION__);
1894 return OK;
1895 }
1896
1897 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
1898 int32_t format = halStreamConfigs.data.i32[i];
1899 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
1900 // image.
1901 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
1902 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
1903 continue;
1904 }
1905
1906 bool sizeAvail = false;
1907 for (size_t j = 0; j < outputs->size(); j+= 4) {
1908 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
1909 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
1910 sizeAvail = true;
1911 break;
1912 }
1913 }
1914 if (sizeAvail) continue;
1915
1916 int64_t stall = 0;
Susmitha Gummallafca67142020-03-05 14:58:30 -08001917 bool useHeic = false;
1918 bool useGrid = false;
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001919 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
1920 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
1921 &useHeic, &useGrid, &stall)) {
1922 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
1923 continue;
1924 }
1925
1926 // HEIC configuration
1927 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1928 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
1929 outputs->insert(outputs->end(), config, config + 4);
1930
1931 // HEIC minFrameDuration
1932 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
1933 if (halStreamDurations.data.i64[j] == format &&
1934 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
1935 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
1936 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1937 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
1938 durations->insert(durations->end(), duration, duration+4);
1939 break;
1940 }
1941 }
1942
1943 // HEIC stallDuration
1944 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1945 halStreamConfigs.data.i32[i+2], stall};
1946 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
1947 }
1948 }
1949 return OK;
1950}
1951
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001952status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags(bool maxResolution) {
1953 int32_t scalerStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001954 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001955 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, maxResolution);
1956 int32_t scalerMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001957 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001958 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, maxResolution);
1959
1960 int32_t heicStreamSizesTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001961 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001962 ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS, maxResolution);
1963 int32_t heicMinFrameDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001964 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001965 ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS, maxResolution);
1966 int32_t heicStallDurationsTag =
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001967 SessionConfigurationUtils::getAppropriateModeTag(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001968 ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS, maxResolution);
1969
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001970 auto& c = mCameraCharacteristics;
1971
1972 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
1973 if (halHeicSupport.count > 1) {
1974 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
1975 __FUNCTION__, halHeicSupport.count);
1976 return BAD_VALUE;
1977 } else if (halHeicSupport.count == 0 ||
1978 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
1979 // Camera HAL doesn't support mandatory stream combinations for HEIC.
1980 return OK;
1981 }
1982
1983 camera_metadata_entry maxJpegAppsSegments =
1984 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1985 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1986 maxJpegAppsSegments.data.u8[0] > 16) {
1987 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1988 __FUNCTION__);
1989 return BAD_VALUE;
1990 }
1991
1992 // Populate HEIC output configurations and its related min frame duration
1993 // and stall duration.
1994 std::vector<int32_t> heicOutputs;
1995 std::vector<int64_t> heicDurations;
1996 std::vector<int64_t> heicStallDurations;
1997
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001998 camera_metadata_entry halStreamConfigs = c.find(scalerStreamSizesTag);
1999 camera_metadata_entry minFrameDurations = c.find(scalerMinFrameDurationsTag);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08002000
2001 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
2002 halStreamConfigs, minFrameDurations);
2003 if (res != OK) {
2004 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
2005 strerror(-res), res);
2006 return res;
2007 }
2008
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002009 c.update(heicStreamSizesTag, heicOutputs.data(), heicOutputs.size());
2010 c.update(heicMinFrameDurationsTag, heicDurations.data(), heicDurations.size());
2011 c.update(heicStallDurationsTag, heicStallDurations.data(), heicStallDurations.size());
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08002012
2013 return OK;
2014}
2015
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002016bool CameraProviderManager::isLogicalCameraLocked(const std::string& id,
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002017 std::vector<std::string>* physicalCameraIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002018 auto deviceInfo = findDeviceInfoLocked(id);
2019 if (deviceInfo == nullptr) return false;
2020
2021 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
2022 *physicalCameraIds = deviceInfo->mPhysicalIds;
2023 }
2024 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002025}
2026
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08002027bool CameraProviderManager::isLogicalCamera(const std::string& id,
2028 std::vector<std::string>* physicalCameraIds) {
2029 std::lock_guard<std::mutex> lock(mInterfaceMutex);
2030 return isLogicalCameraLocked(id, physicalCameraIds);
2031}
2032
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002033status_t CameraProviderManager::getSystemCameraKind(const std::string& id,
2034 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002035 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002036 return getSystemCameraKindLocked(id, kind);
Jayant Chowdhary847947d2019-08-30 18:02:59 -07002037}
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002038
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002039status_t CameraProviderManager::getSystemCameraKindLocked(const std::string& id,
2040 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002041 auto deviceInfo = findDeviceInfoLocked(id);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002042 if (deviceInfo != nullptr) {
2043 *kind = deviceInfo->mSystemCameraKind;
2044 return OK;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002045 }
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002046 // If this is a hidden physical camera, we should return what kind of
2047 // camera the enclosing logical camera is.
2048 auto isHiddenAndParent = isHiddenPhysicalCameraInternal(id);
2049 if (isHiddenAndParent.first) {
2050 LOG_ALWAYS_FATAL_IF(id == isHiddenAndParent.second->mId,
2051 "%s: hidden physical camera id %s and enclosing logical camera id %s are the same",
2052 __FUNCTION__, id.c_str(), isHiddenAndParent.second->mId.c_str());
2053 return getSystemCameraKindLocked(isHiddenAndParent.second->mId, kind);
2054 }
2055 // Neither a hidden physical camera nor a logical camera
2056 return NAME_NOT_FOUND;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002057}
2058
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002059bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) const {
Emilian Peev7fe6c422021-09-08 13:43:20 -07002060 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002061 return isHiddenPhysicalCameraInternal(cameraId).first;
2062}
2063
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002064status_t CameraProviderManager::filterSmallJpegSizes(const std::string& cameraId) {
Emilian Peev7fe6c422021-09-08 13:43:20 -07002065 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wang89db2992021-05-20 13:09:48 -07002066 for (auto& provider : mProviders) {
2067 for (auto& deviceInfo : provider->mDevices) {
2068 if (deviceInfo->mId == cameraId) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002069 return deviceInfo->filterSmallJpegSizes();
Shuzhen Wang89db2992021-05-20 13:09:48 -07002070 }
2071 }
2072 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002073 return NAME_NOT_FOUND;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002074}
2075
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002076std::pair<bool, CameraProviderManager::ProviderInfo::DeviceInfo *>
2077CameraProviderManager::isHiddenPhysicalCameraInternal(const std::string& cameraId) const {
2078 auto falseRet = std::make_pair(false, nullptr);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002079 for (auto& provider : mProviders) {
2080 for (auto& deviceInfo : provider->mDevices) {
2081 if (deviceInfo->mId == cameraId) {
2082 // cameraId is found in public camera IDs advertised by the
2083 // provider.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002084 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002085 }
2086 }
2087 }
2088
2089 for (auto& provider : mProviders) {
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00002090 IPCTransport transport = provider->getIPCTransport();
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002091 for (auto& deviceInfo : provider->mDevices) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002092 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002093 if (deviceInfo->mIsLogicalCamera) {
2094 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
2095 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002096 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
2097 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00002098 if (transport == IPCTransport::HIDL &&
2099 deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002100 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
2101 __FUNCTION__, deviceVersion, cameraId.c_str());
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002102 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002103 } else {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002104 return std::make_pair(true, deviceInfo.get());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002105 }
2106 }
2107 }
2108 }
2109 }
2110
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07002111 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002112}
2113
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002114status_t CameraProviderManager::tryToInitializeAidlProviderLocked(
2115 const std::string& providerName, const sp<ProviderInfo>& providerInfo) {
2116 using aidl::android::hardware::camera::provider::ICameraProvider;
Jayant Chowdharyd65d9442023-07-11 01:18:06 +00002117
Avichal Rakesh682788a2024-01-11 18:01:36 -08002118 std::shared_ptr<ICameraProvider> interface;
2119 if (flags::delay_lazy_hal_instantiation()) {
2120 // Only get remote instance if already running. Lazy Providers will be
2121 // woken up later.
2122 interface = mAidlServiceProxy->tryGetService(providerName);
2123 } else {
2124 interface = mAidlServiceProxy->getService(providerName);
2125 }
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002126
2127 if (interface == nullptr) {
2128 ALOGW("%s: AIDL Camera provider HAL '%s' is not actually available", __FUNCTION__,
2129 providerName.c_str());
2130 return BAD_VALUE;
2131 }
2132
2133 AidlProviderInfo *aidlProviderInfo = static_cast<AidlProviderInfo *>(providerInfo.get());
2134 return aidlProviderInfo->initializeAidlProvider(interface, mDeviceState);
2135}
2136
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002137status_t CameraProviderManager::tryToInitializeHidlProviderLocked(
Emilian Peevc93cac22020-08-17 16:00:10 -07002138 const std::string& providerName, const sp<ProviderInfo>& providerInfo) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002139 sp<provider::V2_4::ICameraProvider> interface;
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002140 interface = mHidlServiceProxy->tryGetService(providerName);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002141
2142 if (interface == nullptr) {
Shuzhen Wang77d04192021-04-02 12:33:54 -07002143 // The interface may not be started yet. In that case, this is not a
2144 // fatal error.
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002145 ALOGW("%s: HIDL Camera provider HAL '%s' is not actually available", __FUNCTION__,
Emilian Peevc93cac22020-08-17 16:00:10 -07002146 providerName.c_str());
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07002147 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002148 }
2149
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002150 HidlProviderInfo *hidlProviderInfo = static_cast<HidlProviderInfo *>(providerInfo.get());
2151 return hidlProviderInfo->initializeHidlProvider(interface, mDeviceState);
Emilian Peevc93cac22020-08-17 16:00:10 -07002152}
2153
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002154status_t CameraProviderManager::addAidlProviderLocked(const std::string& newProvider) {
2155 // Several camera provider instances can be temporarily present.
2156 // Defer initialization of a new instance until the older instance is properly removed.
2157 auto providerInstance = newProvider + "-" + std::to_string(mProviderInstanceId);
2158 bool providerPresent = false;
2159 bool preexisting =
2160 (mAidlProviderWithBinders.find(newProvider) != mAidlProviderWithBinders.end());
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002161 using aidl::android::hardware::camera::provider::ICameraProvider;
Jayant Chowdhary8e8542f2024-09-10 00:46:35 +00002162
2163 // 'newProvider' has the fully qualified name of the provider service in case of AIDL.
2164 // ProviderInfo::mProviderName also has the fully qualified name - so we just compare them
2165 // here.
2166 std::string providerNameUsed = newProvider;
Jayant Chowdharyd65d9442023-07-11 01:18:06 +00002167
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002168 for (const auto& providerInfo : mProviders) {
Jayant Chowdharyd65d9442023-07-11 01:18:06 +00002169 if (providerInfo->mProviderName == providerNameUsed) {
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002170 ALOGW("%s: Camera provider HAL with name '%s' already registered",
2171 __FUNCTION__, newProvider.c_str());
2172 // Do not add new instances for lazy HAL external provider or aidl
2173 // binders previously seen.
2174 if (preexisting || providerInfo->isExternalLazyHAL()) {
2175 return ALREADY_EXISTS;
2176 } else {
2177 ALOGW("%s: The new provider instance will get initialized immediately after the"
2178 " currently present instance is removed!", __FUNCTION__);
2179 providerPresent = true;
2180 break;
2181 }
2182 }
2183 }
2184
2185 sp<AidlProviderInfo> providerInfo =
Jayant Chowdharyd65d9442023-07-11 01:18:06 +00002186 new AidlProviderInfo(providerNameUsed, providerInstance, this);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002187
2188 if (!providerPresent) {
2189 status_t res = tryToInitializeAidlProviderLocked(newProvider, providerInfo);
2190 if (res != OK) {
2191 return res;
2192 }
2193 mAidlProviderWithBinders.emplace(newProvider);
2194 }
2195
2196 mProviders.push_back(providerInfo);
2197 mProviderInstanceId++;
2198
2199 return OK;
2200}
2201
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002202status_t CameraProviderManager::addHidlProviderLocked(const std::string& newProvider,
Emilian Peevc93cac22020-08-17 16:00:10 -07002203 bool preexisting) {
2204 // Several camera provider instances can be temporarily present.
2205 // Defer initialization of a new instance until the older instance is properly removed.
2206 auto providerInstance = newProvider + "-" + std::to_string(mProviderInstanceId);
2207 bool providerPresent = false;
2208 for (const auto& providerInfo : mProviders) {
2209 if (providerInfo->mProviderName == newProvider) {
2210 ALOGW("%s: Camera provider HAL with name '%s' already registered",
2211 __FUNCTION__, newProvider.c_str());
Valentin Iftime29e2e152021-08-13 15:17:33 +02002212 // Do not add new instances for lazy HAL external provider
2213 if (preexisting || providerInfo->isExternalLazyHAL()) {
Emilian Peevc93cac22020-08-17 16:00:10 -07002214 return ALREADY_EXISTS;
Valentin Iftime29e2e152021-08-13 15:17:33 +02002215 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07002216 ALOGW("%s: The new provider instance will get initialized immediately after the"
2217 " currently present instance is removed!", __FUNCTION__);
2218 providerPresent = true;
2219 break;
2220 }
2221 }
2222 }
2223
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002224 sp<HidlProviderInfo> providerInfo = new HidlProviderInfo(newProvider, providerInstance, this);
Emilian Peevc93cac22020-08-17 16:00:10 -07002225 if (!providerPresent) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002226 status_t res = tryToInitializeHidlProviderLocked(newProvider, providerInfo);
Emilian Peevc93cac22020-08-17 16:00:10 -07002227 if (res != OK) {
2228 return res;
2229 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002230 }
2231
2232 mProviders.push_back(providerInfo);
Emilian Peevc93cac22020-08-17 16:00:10 -07002233 mProviderInstanceId++;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002234
2235 return OK;
2236}
2237
2238status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07002239 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002240 std::unique_lock<std::mutex> lock(mInterfaceMutex);
Austin Borger1c1bee02023-06-01 16:51:35 -07002241 std::vector<std::string> removedDeviceIds;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002242 status_t res = NAME_NOT_FOUND;
Emilian Peevc93cac22020-08-17 16:00:10 -07002243 std::string removedProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002244 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
Emilian Peevc93cac22020-08-17 16:00:10 -07002245 if ((*it)->mProviderInstance == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002246 removedDeviceIds.reserve((*it)->mDevices.size());
2247 for (auto& deviceInfo : (*it)->mDevices) {
Austin Borger1c1bee02023-06-01 16:51:35 -07002248 removedDeviceIds.push_back(deviceInfo->mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002249 }
Emilian Peevc93cac22020-08-17 16:00:10 -07002250 removedProviderName = (*it)->mProviderName;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002251 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002252 res = OK;
2253 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002254 }
2255 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002256 if (res != OK) {
2257 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
2258 provider.c_str());
2259 } else {
Emilian Peevc93cac22020-08-17 16:00:10 -07002260 // Check if there are any newer camera instances from the same provider and try to
2261 // initialize.
2262 for (const auto& providerInfo : mProviders) {
2263 if (providerInfo->mProviderName == removedProviderName) {
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002264 IPCTransport providerTransport = providerInfo->getIPCTransport();
2265 switch(providerTransport) {
2266 case IPCTransport::HIDL:
2267 return tryToInitializeHidlProviderLocked(removedProviderName, providerInfo);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002268 case IPCTransport::AIDL:
Jayant Chowdhary8e8542f2024-09-10 00:46:35 +00002269 return tryToInitializeAidlProviderLocked(removedProviderName,
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002270 providerInfo);
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002271 default:
Eino-Ville Talvalab7723202024-06-24 17:45:51 -07002272 ALOGE("%s Unsupported Transport %d", __FUNCTION__, eToI(providerTransport));
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002273 }
Emilian Peevc93cac22020-08-17 16:00:10 -07002274 }
2275 }
2276
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002277 // Inform camera service of loss of presence for all the devices from this provider,
2278 // without lock held for reentrancy
2279 sp<StatusListener> listener = getStatusListener();
2280 if (listener != nullptr) {
2281 lock.unlock();
2282 for (auto& id : removedDeviceIds) {
2283 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
2284 }
Emilian Peevc93cac22020-08-17 16:00:10 -07002285 lock.lock();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002286 }
Emilian Peevc93cac22020-08-17 16:00:10 -07002287
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002288 }
2289 return res;
2290}
2291
2292sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
2293 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002294}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002295/**** Methods for ProviderInfo ****/
2296
2297
2298CameraProviderManager::ProviderInfo::ProviderInfo(
2299 const std::string &providerName,
Emilian Peevc93cac22020-08-17 16:00:10 -07002300 const std::string &providerInstance,
Jing Mikec7f9b132023-03-12 11:12:04 +08002301 [[maybe_unused]] CameraProviderManager *manager) :
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002302 mProviderName(providerName),
Emilian Peevc93cac22020-08-17 16:00:10 -07002303 mProviderInstance(providerInstance),
Emilian Peev71c73a22017-03-21 16:35:51 +00002304 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01002305 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002306 mManager(manager) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002307}
2308
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002309const std::string& CameraProviderManager::ProviderInfo::getType() const {
2310 return mType;
2311}
2312
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002313status_t CameraProviderManager::ProviderInfo::addDevice(
2314 const std::string& name, CameraDeviceStatus initialStatus,
2315 /*out*/ std::string* parsedId) {
2316
2317 ALOGI("Enumerating new camera device: %s", name.c_str());
2318
2319 uint16_t major, minor;
2320 std::string type, id;
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00002321 IPCTransport transport = getIPCTransport();
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002322
2323 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
2324 if (res != OK) {
2325 return res;
2326 }
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002327
2328 if (type != mType) {
2329 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
2330 type.c_str(), mType.c_str());
2331 return BAD_VALUE;
2332 }
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00002333 if (mManager->isValidDeviceLocked(id, major, transport)) {
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002334 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
2335 name.c_str(), id.c_str(), major);
2336 return BAD_VALUE;
2337 }
2338
2339 std::unique_ptr<DeviceInfo> deviceInfo;
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00002340 switch (transport) {
2341 case IPCTransport::HIDL:
2342 switch (major) {
2343 case 3:
2344 break;
2345 default:
2346 ALOGE("%s: Device %s: Unsupported HIDL device HAL major version %d:",
2347 __FUNCTION__, name.c_str(), major);
2348 return BAD_VALUE;
2349 }
2350 break;
2351 case IPCTransport::AIDL:
2352 if (major != 1) {
2353 ALOGE("%s: Device %s: Unsupported AIDL device HAL major version %d:", __FUNCTION__,
2354 name.c_str(), major);
2355 return BAD_VALUE;
2356 }
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002357 break;
2358 default:
Eino-Ville Talvalab7723202024-06-24 17:45:51 -07002359 ALOGE("%s Invalid transport %d", __FUNCTION__, eToI(transport));
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002360 return BAD_VALUE;
2361 }
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00002362
2363 deviceInfo = initializeDeviceInfo(name, mProviderTagid, id, minor);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002364 if (deviceInfo == nullptr) return BAD_VALUE;
2365 deviceInfo->notifyDeviceStateChange(getDeviceState());
2366 deviceInfo->mStatus = initialStatus;
2367 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
2368
2369 mDevices.push_back(std::move(deviceInfo));
2370
2371 mUniqueCameraIds.insert(id);
2372 if (isAPI1Compatible) {
2373 // addDevice can be called more than once for the same camera id if HAL
2374 // supports openLegacy.
2375 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
2376 id) == mUniqueAPI1CompatibleCameraIds.end()) {
2377 mUniqueAPI1CompatibleCameraIds.push_back(id);
2378 }
2379 }
2380
2381 if (parsedId != nullptr) {
2382 *parsedId = id;
2383 }
2384 return OK;
2385}
2386
Austin Borger1c1bee02023-06-01 16:51:35 -07002387void CameraProviderManager::ProviderInfo::removeDevice(const std::string &id) {
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01002388 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
2389 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002390 mUniqueCameraIds.erase(id);
Shuzhen Wang3d316f32022-10-25 20:33:34 +00002391 mUnavailablePhysicalCameras.erase(id);
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002392 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002393 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
Valentin Iftime29e2e152021-08-13 15:17:33 +02002394 mUniqueAPI1CompatibleCameraIds.begin(),
2395 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002396 }
Valentin Iftime29e2e152021-08-13 15:17:33 +02002397
2398 // Remove reference to camera provider to avoid pointer leak when
2399 // unplugging external camera while in use with lazy HALs
2400 mManager->removeRef(DeviceMode::CAMERA, id);
2401 mManager->removeRef(DeviceMode::TORCH, id);
2402
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01002403 mDevices.erase(it);
2404 break;
2405 }
2406 }
2407}
2408
Valentin Iftime29e2e152021-08-13 15:17:33 +02002409void CameraProviderManager::ProviderInfo::removeAllDevices() {
2410 std::lock_guard<std::mutex> lock(mLock);
2411
2412 auto itDevices = mDevices.begin();
2413 while (itDevices != mDevices.end()) {
2414 std::string id = (*itDevices)->mId;
2415 std::string deviceName = (*itDevices)->mName;
2416 removeDevice(id);
2417 // device was removed, reset iterator
2418 itDevices = mDevices.begin();
2419
2420 //notify CameraService of status change
2421 sp<StatusListener> listener = mManager->getStatusListener();
2422 if (listener != nullptr) {
2423 mLock.unlock();
2424 ALOGV("%s: notify device not_present: %s",
2425 __FUNCTION__,
2426 deviceName.c_str());
Austin Borger1c1bee02023-06-01 16:51:35 -07002427 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
Valentin Iftime29e2e152021-08-13 15:17:33 +02002428 mLock.lock();
2429 }
2430 }
2431}
2432
2433bool CameraProviderManager::ProviderInfo::isExternalLazyHAL() const {
Jayant Chowdharyd65d9442023-07-11 01:18:06 +00002434 std::string providerName = mProviderName;
Jayant Chowdhary8e8542f2024-09-10 00:46:35 +00002435 if (getIPCTransport() == IPCTransport::AIDL) {
Jayant Chowdharyd65d9442023-07-11 01:18:06 +00002436 using aidl::android::hardware::camera::provider::ICameraProvider;
2437 providerName =
2438 mProviderName.substr(std::string(ICameraProvider::descriptor).size() + 1);
2439 }
2440 return kEnableLazyHal && (providerName == kExternalProviderName);
Valentin Iftime29e2e152021-08-13 15:17:33 +02002441}
2442
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002443status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08002444 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
Emilian Peevc93cac22020-08-17 16:00:10 -07002445 mProviderInstance.c_str(),
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08002446 mMinorVersion,
2447 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002448 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002449
2450 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002451 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
2452 device->mVersion.get_major(), device->mVersion.get_minor());
2453 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
2454 if (device->mResourceCost.conflictingDevices.size() == 0) {
2455 dprintf(fd, " Conflicting devices: None\n");
2456 } else {
2457 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002458 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002459 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002460 device->mResourceCost.conflictingDevices[i].c_str());
2461 }
2462 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002463 dprintf(fd, " API1 info:\n");
2464 dprintf(fd, " Has a flash unit: %s\n",
2465 device->hasFlashUnit() ? "true" : "false");
2466 hardware::CameraInfo info;
Austin Borger18b30a72022-10-27 12:20:29 -07002467 int portraitRotation;
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002468 status_t res = device->getCameraInfo(
2469 /*rotationOverride*/hardware::ICameraService::ROTATION_OVERRIDE_NONE,
2470 &portraitRotation, &info);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002471 if (res != OK) {
2472 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
2473 strerror(-res), res);
2474 } else {
2475 dprintf(fd, " Facing: %s\n",
2476 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
2477 dprintf(fd, " Orientation: %d\n", info.orientation);
2478 }
2479 CameraMetadata info2;
Austin Borger18b30a72022-10-27 12:20:29 -07002480 res = device->getCameraCharacteristics(true /*overrideForPerfClass*/, &info2,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002481 hardware::ICameraService::ROTATION_OVERRIDE_NONE);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002482 if (res == INVALID_OPERATION) {
2483 dprintf(fd, " API2 not directly supported\n");
2484 } else if (res != OK) {
2485 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
2486 strerror(-res), res);
2487 } else {
2488 dprintf(fd, " API2 camera characteristics:\n");
2489 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
2490 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002491
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002492 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002493 if (device->mIsLogicalCamera) {
2494 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002495 // Skip if physical id is an independent camera
2496 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
2497 != mProviderPublicCameraIds.end()) {
2498 continue;
2499 }
2500
2501 CameraMetadata physicalInfo;
2502 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
2503 if (status == OK) {
2504 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
2505 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
2506 }
2507 }
2508 }
2509
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002510 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
2511 device->mVersion.get_major(), device->mVersion.get_minor());
2512 res = device->dumpState(fd);
2513 if (res != OK) {
2514 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
2515 device->mName.c_str(), strerror(-res), res);
2516 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002517 }
2518 return OK;
2519}
2520
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08002521std::vector<std::unordered_set<std::string>>
2522CameraProviderManager::ProviderInfo::getConcurrentCameraIdCombinations() {
2523 std::lock_guard<std::mutex> lock(mLock);
2524 return mConcurrentCameraIdCombinations;
2525}
2526
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002527void CameraProviderManager::ProviderInfo::cameraDeviceStatusChangeInternal(
2528 const std::string& cameraDeviceName, CameraDeviceStatus newStatus) {
2529 sp<StatusListener> listener;
2530 std::string id;
2531 std::lock_guard<std::mutex> lock(mInitLock);
2532 CameraDeviceStatus internalNewStatus = newStatus;
2533 if (!mInitialized) {
2534 mCachedStatus.emplace_back(false /*isPhysicalCameraStatus*/,
Austin Borger1c1bee02023-06-01 16:51:35 -07002535 cameraDeviceName, std::string(), internalNewStatus);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002536 return;
2537 }
2538
2539 {
2540 std::lock_guard<std::mutex> lock(mLock);
2541 if (OK != cameraDeviceStatusChangeLocked(&id, cameraDeviceName, newStatus)) {
2542 return;
2543 }
2544 listener = mManager->getStatusListener();
2545 }
2546
2547 // Call without lock held to allow reentrancy into provider manager
2548 if (listener != nullptr) {
Austin Borger1c1bee02023-06-01 16:51:35 -07002549 listener->onDeviceStatusChanged(id, internalNewStatus);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002550 }
2551}
2552
2553status_t CameraProviderManager::ProviderInfo::cameraDeviceStatusChangeLocked(
2554 std::string* id, const std::string& cameraDeviceName,
2555 CameraDeviceStatus newStatus) {
2556 bool known = false;
2557 std::string cameraId;
2558 for (auto& deviceInfo : mDevices) {
2559 if (deviceInfo->mName == cameraDeviceName) {
2560 Mutex::Autolock l(deviceInfo->mDeviceAvailableLock);
2561 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
2562 FrameworkDeviceStatusToString(newStatus),
2563 FrameworkDeviceStatusToString(deviceInfo->mStatus));
2564 deviceInfo->mStatus = newStatus;
2565 // TODO: Handle device removal (NOT_PRESENT)
2566 cameraId = deviceInfo->mId;
2567 known = true;
2568 deviceInfo->mIsDeviceAvailable =
2569 (newStatus == CameraDeviceStatus::PRESENT);
2570 deviceInfo->mDeviceAvailableSignal.signal();
2571 break;
2572 }
2573 }
2574 // Previously unseen device; status must not be NOT_PRESENT
2575 if (!known) {
2576 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
2577 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
2578 mProviderName.c_str(), cameraDeviceName.c_str());
2579 return BAD_VALUE;
2580 }
2581 addDevice(cameraDeviceName, newStatus, &cameraId);
2582 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
2583 removeDevice(cameraId);
2584 } else if (isExternalLazyHAL()) {
2585 // Do not notify CameraService for PRESENT->PRESENT (lazy HAL restart)
2586 // because NOT_AVAILABLE is set on CameraService::connect and a PRESENT
2587 // notif. would overwrite it
2588 return BAD_VALUE;
2589 }
2590
2591 if (reCacheConcurrentStreamingCameraIdsLocked() != OK) {
2592 ALOGE("%s: CameraProvider %s could not re-cache concurrent streaming camera id list ",
2593 __FUNCTION__, mProviderName.c_str());
2594 }
2595 *id = cameraId;
2596 return OK;
2597}
2598
2599void CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChangeInternal(
2600 const std::string& cameraDeviceName,
2601 const std::string& physicalCameraDeviceName,
2602 CameraDeviceStatus newStatus) {
2603 sp<StatusListener> listener;
2604 std::string id;
2605 std::string physicalId;
2606 std::lock_guard<std::mutex> lock(mInitLock);
2607 if (!mInitialized) {
2608 mCachedStatus.emplace_back(true /*isPhysicalCameraStatus*/, cameraDeviceName,
2609 physicalCameraDeviceName, newStatus);
2610 return;
2611 }
2612
2613 {
2614 std::lock_guard<std::mutex> lock(mLock);
2615
2616 if (OK != physicalCameraDeviceStatusChangeLocked(&id, &physicalId, cameraDeviceName,
2617 physicalCameraDeviceName, newStatus)) {
2618 return;
2619 }
2620
2621 listener = mManager->getStatusListener();
2622 }
2623 // Call without lock held to allow reentrancy into provider manager
2624 if (listener != nullptr) {
Austin Borger1c1bee02023-06-01 16:51:35 -07002625 listener->onDeviceStatusChanged(id, physicalId, newStatus);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002626 }
2627 return;
2628}
2629
2630status_t CameraProviderManager::ProviderInfo::physicalCameraDeviceStatusChangeLocked(
2631 std::string* id, std::string* physicalId,
2632 const std::string& cameraDeviceName,
2633 const std::string& physicalCameraDeviceName,
2634 CameraDeviceStatus newStatus) {
2635 bool known = false;
2636 std::string cameraId;
2637 for (auto& deviceInfo : mDevices) {
2638 if (deviceInfo->mName == cameraDeviceName) {
2639 cameraId = deviceInfo->mId;
2640 if (!deviceInfo->mIsLogicalCamera) {
2641 ALOGE("%s: Invalid combination of camera id %s, physical id %s",
2642 __FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
2643 return BAD_VALUE;
2644 }
2645 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
2646 physicalCameraDeviceName) == deviceInfo->mPhysicalIds.end()) {
2647 ALOGE("%s: Invalid combination of camera id %s, physical id %s",
2648 __FUNCTION__, cameraId.c_str(), physicalCameraDeviceName.c_str());
2649 return BAD_VALUE;
2650 }
2651 ALOGI("Camera device %s physical device %s status is now %s",
2652 cameraDeviceName.c_str(), physicalCameraDeviceName.c_str(),
2653 FrameworkDeviceStatusToString(newStatus));
2654 known = true;
2655 break;
2656 }
2657 }
2658 // Previously unseen device; status must not be NOT_PRESENT
2659 if (!known) {
2660 ALOGW("Camera provider %s says an unknown camera device %s-%s is not present. Curious.",
2661 mProviderName.c_str(), cameraDeviceName.c_str(),
2662 physicalCameraDeviceName.c_str());
2663 return BAD_VALUE;
2664 }
2665
Shuzhen Wang3d316f32022-10-25 20:33:34 +00002666 if (mUnavailablePhysicalCameras.count(cameraId) == 0) {
2667 mUnavailablePhysicalCameras.emplace(cameraId, std::set<std::string>{});
2668 }
2669 if (newStatus != CameraDeviceStatus::PRESENT) {
2670 mUnavailablePhysicalCameras[cameraId].insert(physicalCameraDeviceName);
2671 } else {
2672 mUnavailablePhysicalCameras[cameraId].erase(physicalCameraDeviceName);
2673 }
2674
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002675 *id = cameraId;
Austin Borger1c1bee02023-06-01 16:51:35 -07002676 *physicalId = physicalCameraDeviceName;
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002677 return OK;
2678}
2679
2680void CameraProviderManager::ProviderInfo::torchModeStatusChangeInternal(
2681 const std::string& cameraDeviceName,
2682 TorchModeStatus newStatus) {
2683 sp<StatusListener> listener;
2684 SystemCameraKind systemCameraKind = SystemCameraKind::PUBLIC;
2685 std::string id;
2686 bool known = false;
2687 {
2688 // Hold mLock for accessing mDevices
2689 std::lock_guard<std::mutex> lock(mLock);
2690 for (auto& deviceInfo : mDevices) {
2691 if (deviceInfo->mName == cameraDeviceName) {
2692 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
2693 FrameworkTorchStatusToString(newStatus));
2694 id = deviceInfo->mId;
2695 known = true;
2696 systemCameraKind = deviceInfo->mSystemCameraKind;
2697 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
2698 mManager->removeRef(CameraProviderManager::DeviceMode::TORCH, id);
2699 }
2700 break;
2701 }
2702 }
2703 if (!known) {
2704 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
Eino-Ville Talvalab7723202024-06-24 17:45:51 -07002705 mProviderName.c_str(), cameraDeviceName.c_str(), eToI(newStatus));
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002706 return;
2707 }
2708 // no lock needed since listener is set up only once during
2709 // CameraProviderManager initialization and then never changed till it is
2710 // destructed.
2711 listener = mManager->getStatusListener();
2712 }
2713 // Call without lock held to allow reentrancy into provider manager
2714 // The problem with holding mLock here is that we
2715 // might be limiting re-entrancy : CameraService::onTorchStatusChanged calls
2716 // back into CameraProviderManager which might try to hold mLock again (eg:
2717 // findDeviceInfo, which should be holding mLock while iterating through
2718 // each provider's devices).
2719 if (listener != nullptr) {
Austin Borger1c1bee02023-06-01 16:51:35 -07002720 listener->onTorchStatusChanged(id, newStatus, systemCameraKind);
Jayant Chowdharya04055f2022-01-03 02:07:49 +00002721 }
2722 return;
2723}
2724
Emilian Peevb50402e2021-09-24 17:41:57 -07002725void CameraProviderManager::ProviderInfo::notifyDeviceInfoStateChangeLocked(
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002726 int64_t newDeviceState) {
Emilian Peevb50402e2021-09-24 17:41:57 -07002727 std::lock_guard<std::mutex> lock(mLock);
2728 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
2729 (*it)->notifyDeviceStateChange(newDeviceState);
2730 }
2731}
2732
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002733CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00002734 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002735 uint16_t minorVersion,
2736 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002737 sp<ProviderInfo> parentProvider,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002738 const std::vector<std::string>& publicCameraIds) :
Jayant Chowdhary16af6ce2023-05-04 10:36:31 -07002739 DeviceInfo(name, tagId, id,
2740 hardware::hidl_version{
2741 static_cast<uint16_t >(
2742 parentProvider->getIPCTransport() == IPCTransport::HIDL ? 3 : 1),
2743 minorVersion},
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002744 publicCameraIds, resourceCost, parentProvider) { }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002745
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07002746void CameraProviderManager::ProviderInfo::DeviceInfo3::notifyDeviceStateChange(int64_t newState) {
Emilian Peevb50402e2021-09-24 17:41:57 -07002747 if (!mDeviceStateOrientationMap.empty() &&
2748 (mDeviceStateOrientationMap.find(newState) != mDeviceStateOrientationMap.end())) {
2749 mCameraCharacteristics.update(ANDROID_SENSOR_ORIENTATION,
2750 &mDeviceStateOrientationMap[newState], 1);
Emilian Peevfa453762023-04-28 15:12:09 -07002751 if (mCameraCharNoPCOverride.get() != nullptr) {
2752 mCameraCharNoPCOverride->update(ANDROID_SENSOR_ORIENTATION,
2753 &mDeviceStateOrientationMap[newState], 1);
2754 }
Emilian Peevb50402e2021-09-24 17:41:57 -07002755 }
2756}
2757
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002758status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002759 int rotationOverride, int *portraitRotation,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002760 hardware::CameraInfo *info) const {
2761 if (info == nullptr) return BAD_VALUE;
2762
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002763 bool freeform_compat_enabled = wm_flags::camera_compat_for_freeform();
2764 if (!freeform_compat_enabled &&
2765 rotationOverride > hardware::ICameraService::ROTATION_OVERRIDE_OVERRIDE_TO_PORTRAIT) {
2766 ALOGW("Camera compat freeform flag disabled but rotation override is %d", rotationOverride);
2767 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002768 camera_metadata_ro_entry facing =
2769 mCameraCharacteristics.find(ANDROID_LENS_FACING);
2770 if (facing.count == 1) {
2771 switch (facing.data.u8[0]) {
2772 case ANDROID_LENS_FACING_BACK:
2773 info->facing = hardware::CAMERA_FACING_BACK;
2774 break;
2775 case ANDROID_LENS_FACING_EXTERNAL:
2776 // Map external to front for legacy API
2777 case ANDROID_LENS_FACING_FRONT:
2778 info->facing = hardware::CAMERA_FACING_FRONT;
2779 break;
2780 }
2781 } else {
2782 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
2783 return NAME_NOT_FOUND;
2784 }
2785
2786 camera_metadata_ro_entry orientation =
2787 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
2788 if (orientation.count == 1) {
2789 info->orientation = orientation.data.i32[0];
2790 } else {
2791 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
2792 return NAME_NOT_FOUND;
2793 }
2794
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002795 if (rotationOverride == hardware::ICameraService::ROTATION_OVERRIDE_OVERRIDE_TO_PORTRAIT
2796 && (info->orientation == 0 || info->orientation == 180)) {
Austin Borger18b30a72022-10-27 12:20:29 -07002797 *portraitRotation = 90;
2798 if (info->facing == hardware::CAMERA_FACING_FRONT) {
2799 info->orientation = (360 + info->orientation - 90) % 360;
2800 } else {
2801 info->orientation = (360 + info->orientation + 90) % 360;
2802 }
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002803 } else if (freeform_compat_enabled &&
2804 rotationOverride == hardware::ICameraService::ROTATION_OVERRIDE_ROTATION_ONLY
2805 && (info->orientation == 90 || info->orientation == 270)) {
2806 *portraitRotation = info->facing == hardware::CAMERA_FACING_BACK ? 90 : 270;
Austin Borger18b30a72022-10-27 12:20:29 -07002807 } else {
2808 *portraitRotation = 0;
2809 }
2810
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002811 return OK;
2812}
Emilian Peevf53f66e2017-04-11 14:29:43 +01002813bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07002814 // Do not advertise NIR cameras to API1 camera app.
2815 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
2816 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
2817 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
2818 return false;
2819 }
2820
Emilian Peevf53f66e2017-04-11 14:29:43 +01002821 bool isBackwardCompatible = false;
2822 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
2823 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
2824 for (size_t i = 0; i < caps.count; i++) {
2825 if (caps.data.u8[i] ==
2826 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2827 isBackwardCompatible = true;
2828 break;
2829 }
2830 }
2831
2832 return isBackwardCompatible;
2833}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002834
2835status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002836 bool overrideForPerfClass, CameraMetadata *characteristics,
2837 int rotationOverride) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002838 if (characteristics == nullptr) return BAD_VALUE;
2839
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002840 if (!overrideForPerfClass && mCameraCharNoPCOverride != nullptr) {
2841 *characteristics = *mCameraCharNoPCOverride;
2842 } else {
2843 *characteristics = mCameraCharacteristics;
2844 }
2845
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00002846 if (rotationOverride == hardware::ICameraService::ROTATION_OVERRIDE_OVERRIDE_TO_PORTRAIT) {
Austin Borger18b30a72022-10-27 12:20:29 -07002847 const auto &lensFacingEntry = characteristics->find(ANDROID_LENS_FACING);
2848 const auto &sensorOrientationEntry = characteristics->find(ANDROID_SENSOR_ORIENTATION);
Austin Borger925abed2023-01-09 12:29:10 -08002849 uint8_t lensFacing = lensFacingEntry.data.u8[0];
Austin Borger18b30a72022-10-27 12:20:29 -07002850 if (lensFacingEntry.count > 0 && sensorOrientationEntry.count > 0) {
Austin Borger18b30a72022-10-27 12:20:29 -07002851 int32_t sensorOrientation = sensorOrientationEntry.data.i32[0];
2852 int32_t newSensorOrientation = sensorOrientation;
2853
2854 if (sensorOrientation == 0 || sensorOrientation == 180) {
2855 if (lensFacing == ANDROID_LENS_FACING_FRONT) {
2856 newSensorOrientation = (360 + sensorOrientation - 90) % 360;
2857 } else if (lensFacing == ANDROID_LENS_FACING_BACK) {
2858 newSensorOrientation = (360 + sensorOrientation + 90) % 360;
2859 }
2860 }
2861
2862 if (newSensorOrientation != sensorOrientation) {
2863 ALOGV("%s: Update ANDROID_SENSOR_ORIENTATION for lens facing %d "
2864 "from %d to %d", __FUNCTION__, lensFacing, sensorOrientation,
2865 newSensorOrientation);
2866 characteristics->update(ANDROID_SENSOR_ORIENTATION, &newSensorOrientation, 1);
2867 }
2868 }
2869
2870 if (characteristics->exists(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS)) {
Austin Borger925abed2023-01-09 12:29:10 -08002871 ALOGV("%s: Erasing ANDROID_INFO_DEVICE_STATE_ORIENTATIONS for lens facing %d",
2872 __FUNCTION__, lensFacing);
Austin Borger18b30a72022-10-27 12:20:29 -07002873 characteristics->erase(ANDROID_INFO_DEVICE_STATE_ORIENTATIONS);
2874 }
2875 }
2876
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002877 return OK;
2878}
2879
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002880status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
2881 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
2882 if (characteristics == nullptr) return BAD_VALUE;
2883 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
2884 mPhysicalCameraCharacteristics.end()) {
2885 return NAME_NOT_FOUND;
2886 }
2887
2888 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
2889 return OK;
2890}
2891
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002892status_t CameraProviderManager::ProviderInfo::DeviceInfo3::filterSmallJpegSizes() {
2893 int32_t thresholdW = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_W;
2894 int32_t thresholdH = SessionConfigurationUtils::PERF_CLASS_JPEG_THRESH_H;
2895
2896 if (mCameraCharNoPCOverride != nullptr) return OK;
2897
2898 mCameraCharNoPCOverride = std::make_unique<CameraMetadata>(mCameraCharacteristics);
Shuzhen Wang89db2992021-05-20 13:09:48 -07002899
2900 // Remove small JPEG sizes from available stream configurations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002901 size_t largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002902 std::vector<int32_t> newStreamConfigs;
2903 camera_metadata_entry streamConfigs =
2904 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
2905 for (size_t i = 0; i < streamConfigs.count; i += 4) {
2906 if ((streamConfigs.data.i32[i] == HAL_PIXEL_FORMAT_BLOB) && (streamConfigs.data.i32[i+3] ==
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002907 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
Shuzhen Wang10f99212023-02-02 18:55:31 -08002908 if (streamConfigs.data.i32[i+1] * streamConfigs.data.i32[i+2] <
2909 thresholdW * thresholdH) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002910 continue;
2911 } else {
2912 largeJpegCount ++;
2913 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002914 }
2915 newStreamConfigs.insert(newStreamConfigs.end(), streamConfigs.data.i32 + i,
2916 streamConfigs.data.i32 + i + 4);
2917 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002918 if (newStreamConfigs.size() == 0 || largeJpegCount == 0) {
2919 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002920 }
2921
2922 // Remove small JPEG sizes from available min frame durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002923 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002924 std::vector<int64_t> newMinDurations;
2925 camera_metadata_entry minDurations =
2926 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
2927 for (size_t i = 0; i < minDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002928 if (minDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
Shuzhen Wang10f99212023-02-02 18:55:31 -08002929 if ((int32_t)minDurations.data.i64[i+1] * (int32_t)minDurations.data.i64[i+2] <
2930 thresholdW * thresholdH) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002931 continue;
2932 } else {
2933 largeJpegCount++;
2934 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002935 }
2936 newMinDurations.insert(newMinDurations.end(), minDurations.data.i64 + i,
2937 minDurations.data.i64 + i + 4);
2938 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002939 if (newMinDurations.size() == 0 || largeJpegCount == 0) {
2940 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002941 }
2942
2943 // Remove small JPEG sizes from available stall durations
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002944 largeJpegCount = 0;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002945 std::vector<int64_t> newStallDurations;
2946 camera_metadata_entry stallDurations =
2947 mCameraCharacteristics.find(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS);
2948 for (size_t i = 0; i < stallDurations.count; i += 4) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002949 if (stallDurations.data.i64[i] == HAL_PIXEL_FORMAT_BLOB) {
Shuzhen Wang10f99212023-02-02 18:55:31 -08002950 if ((int32_t)stallDurations.data.i64[i+1] * (int32_t)stallDurations.data.i64[i+2] <
2951 thresholdW * thresholdH) {
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002952 continue;
2953 } else {
2954 largeJpegCount++;
2955 }
Shuzhen Wang89db2992021-05-20 13:09:48 -07002956 }
2957 newStallDurations.insert(newStallDurations.end(), stallDurations.data.i64 + i,
2958 stallDurations.data.i64 + i + 4);
2959 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002960 if (newStallDurations.size() == 0 || largeJpegCount == 0) {
2961 return BAD_VALUE;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002962 }
2963
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002964 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
2965 newStreamConfigs.data(), newStreamConfigs.size());
2966 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
2967 newMinDurations.data(), newMinDurations.size());
2968 mCameraCharacteristics.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
2969 newStallDurations.data(), newStallDurations.size());
2970
Shuzhen Wang89db2992021-05-20 13:09:48 -07002971 // Re-generate metadata tags that have dependencies on BLOB sizes
2972 auto res = addDynamicDepthTags();
2973 if (OK != res) {
2974 ALOGE("%s: Failed to append dynamic depth tags: %s (%d)", __FUNCTION__,
2975 strerror(-res), res);
Shuzhen Wang2ebb8392021-06-21 23:31:10 -07002976 // Allow filtering of small JPEG sizes to succeed even if dynamic depth
2977 // tags fail to generate.
Shuzhen Wang89db2992021-05-20 13:09:48 -07002978 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002979
2980 return OK;
Shuzhen Wang89db2992021-05-20 13:09:48 -07002981}
2982
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002983status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
2984 std::string *type, uint32_t *id) {
2985 // Format must be "<type>/<id>"
2986#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
2987 "Should match '<type>/<id>' - "
2988
2989 if (!type || !id) return INVALID_OPERATION;
2990
2991 std::string::size_type slashIdx = name.find('/');
2992 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
2993 ALOGE(ERROR_MSG_PREFIX
2994 "does not have / separator between type and id",
2995 __FUNCTION__, name.c_str());
2996 return BAD_VALUE;
2997 }
2998
2999 std::string typeVal = name.substr(0, slashIdx);
3000
3001 char *endPtr;
3002 errno = 0;
3003 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
3004 if (errno != 0) {
3005 ALOGE(ERROR_MSG_PREFIX
3006 "cannot parse provider id as an integer: %s (%d)",
3007 __FUNCTION__, name.c_str(), strerror(errno), errno);
3008 return BAD_VALUE;
3009 }
3010 if (endPtr != name.c_str() + name.size()) {
3011 ALOGE(ERROR_MSG_PREFIX
3012 "provider id has unexpected length",
3013 __FUNCTION__, name.c_str());
3014 return BAD_VALUE;
3015 }
3016 if (idVal < 0) {
3017 ALOGE(ERROR_MSG_PREFIX
3018 "id is negative: %ld",
3019 __FUNCTION__, name.c_str(), idVal);
3020 return BAD_VALUE;
3021 }
3022
3023#undef ERROR_MSG_PREFIX
3024
3025 *type = typeVal;
3026 *id = static_cast<uint32_t>(idVal);
3027
3028 return OK;
3029}
3030
Emilian Peev71c73a22017-03-21 16:35:51 +00003031metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
3032 const std::string &name) {
3033 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
3034 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
3035 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
3036 ret = 0;
3037 }
3038
3039 return ret;
3040}
3041
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003042status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
3043 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
3044
3045 // Format must be "device@<major>.<minor>/<type>/<id>"
3046
3047#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
3048 "Should match 'device@<major>.<minor>/<type>/<id>' - "
3049
3050 if (!major || !minor || !type || !id) return INVALID_OPERATION;
3051
3052 // Verify starting prefix
3053 const char expectedPrefix[] = "device@";
3054
3055 if (name.find(expectedPrefix) != 0) {
3056 ALOGE(ERROR_MSG_PREFIX
3057 "does not start with '%s'",
3058 __FUNCTION__, name.c_str(), expectedPrefix);
3059 return BAD_VALUE;
3060 }
3061
3062 // Extract major/minor versions
3063 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
3064 std::string::size_type dotIdx = name.find('.', atIdx);
3065 if (dotIdx == std::string::npos) {
3066 ALOGE(ERROR_MSG_PREFIX
3067 "does not have @<major>. version section",
3068 __FUNCTION__, name.c_str());
3069 return BAD_VALUE;
3070 }
3071 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
3072 if (typeSlashIdx == std::string::npos) {
3073 ALOGE(ERROR_MSG_PREFIX
3074 "does not have .<minor>/ version section",
3075 __FUNCTION__, name.c_str());
3076 return BAD_VALUE;
3077 }
3078
3079 char *endPtr;
3080 errno = 0;
3081 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
3082 if (errno != 0) {
3083 ALOGE(ERROR_MSG_PREFIX
3084 "cannot parse major version: %s (%d)",
3085 __FUNCTION__, name.c_str(), strerror(errno), errno);
3086 return BAD_VALUE;
3087 }
3088 if (endPtr != name.c_str() + dotIdx) {
3089 ALOGE(ERROR_MSG_PREFIX
3090 "major version has unexpected length",
3091 __FUNCTION__, name.c_str());
3092 return BAD_VALUE;
3093 }
3094 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
3095 if (errno != 0) {
3096 ALOGE(ERROR_MSG_PREFIX
3097 "cannot parse minor version: %s (%d)",
3098 __FUNCTION__, name.c_str(), strerror(errno), errno);
3099 return BAD_VALUE;
3100 }
3101 if (endPtr != name.c_str() + typeSlashIdx) {
3102 ALOGE(ERROR_MSG_PREFIX
3103 "minor version has unexpected length",
3104 __FUNCTION__, name.c_str());
3105 return BAD_VALUE;
3106 }
3107 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
3108 ALOGE(ERROR_MSG_PREFIX
3109 "major/minor version is out of range of uint16_t: %ld.%ld",
3110 __FUNCTION__, name.c_str(), majorVal, minorVal);
3111 return BAD_VALUE;
3112 }
3113
3114 // Extract type and id
3115
3116 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
3117 if (instanceSlashIdx == std::string::npos) {
3118 ALOGE(ERROR_MSG_PREFIX
3119 "does not have /<type>/ component",
3120 __FUNCTION__, name.c_str());
3121 return BAD_VALUE;
3122 }
3123 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
3124
3125 if (instanceSlashIdx == name.size() - 1) {
3126 ALOGE(ERROR_MSG_PREFIX
3127 "does not have an /<id> component",
3128 __FUNCTION__, name.c_str());
3129 return BAD_VALUE;
3130 }
3131 std::string idVal = name.substr(instanceSlashIdx + 1);
3132
3133#undef ERROR_MSG_PREFIX
3134
3135 *major = static_cast<uint16_t>(majorVal);
3136 *minor = static_cast<uint16_t>(minorVal);
3137 *type = typeVal;
3138 *id = idVal;
3139
3140 return OK;
3141}
3142
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003143CameraProviderManager::ProviderInfo::~ProviderInfo() {
3144 // Destruction of ProviderInfo is only supposed to happen when the respective
3145 // CameraProvider interface dies, so do not unregister callbacks.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003146}
3147
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003148// Expects to have mInterfaceMutex locked
3149std::vector<std::unordered_set<std::string>>
Jayant Chowdharycad23c22020-03-10 15:04:59 -07003150CameraProviderManager::getConcurrentCameraIds() const {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003151 std::vector<std::unordered_set<std::string>> deviceIdCombinations;
3152 std::lock_guard<std::mutex> lock(mInterfaceMutex);
3153 for (auto &provider : mProviders) {
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08003154 for (auto &combinations : provider->getConcurrentCameraIdCombinations()) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003155 deviceIdCombinations.push_back(combinations);
3156 }
3157 }
3158 return deviceIdCombinations;
3159}
3160
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003161// Checks if the containing vector of sets has any set that contains all of the
3162// camera ids in cameraIdsAndSessionConfigs.
3163static bool checkIfSetContainsAll(
3164 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
3165 const std::vector<std::unordered_set<std::string>> &containingSets) {
3166 for (auto &containingSet : containingSets) {
3167 bool didHaveAll = true;
3168 for (auto &cameraIdAndSessionConfig : cameraIdsAndSessionConfigs) {
3169 if (containingSet.find(cameraIdAndSessionConfig.mCameraId) == containingSet.end()) {
3170 // a camera id doesn't belong to this set, keep looking in other
3171 // sets
3172 didHaveAll = false;
3173 break;
3174 }
3175 }
3176 if (didHaveAll) {
3177 // found a set that has all camera ids, lets return;
3178 return true;
3179 }
3180 }
3181 return false;
3182}
3183
3184status_t CameraProviderManager::isConcurrentSessionConfigurationSupported(
3185 const std::vector<CameraIdAndSessionConfiguration> &cameraIdsAndSessionConfigs,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07003186 const std::set<std::string>& perfClassPrimaryCameraIds,
3187 int targetSdkVersion, bool *isSupported) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003188 std::lock_guard<std::mutex> lock(mInterfaceMutex);
3189 // Check if all the devices are a subset of devices advertised by the
3190 // same provider through getConcurrentStreamingCameraIds()
3191 // TODO: we should also do a findDeviceInfoLocked here ?
3192 for (auto &provider : mProviders) {
3193 if (checkIfSetContainsAll(cameraIdsAndSessionConfigs,
Jayant Chowdharycbe770a2020-02-14 11:14:46 -08003194 provider->getConcurrentCameraIdCombinations())) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003195 return provider->isConcurrentSessionConfigurationSupported(
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07003196 cameraIdsAndSessionConfigs, perfClassPrimaryCameraIds, targetSdkVersion,
3197 isSupported);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -08003198 }
3199 }
3200 *isSupported = false;
3201 //The set of camera devices were not found
3202 return INVALID_OPERATION;
3203}
3204
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003205status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
Austin Borger18b30a72022-10-27 12:20:29 -07003206 bool overrideForPerfClass, CameraMetadata* characteristics,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00003207 int rotationOverride) const {
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00003208 auto deviceInfo = findDeviceInfoLocked(id);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003209 if (deviceInfo != nullptr) {
Austin Borger18b30a72022-10-27 12:20:29 -07003210 return deviceInfo->getCameraCharacteristics(overrideForPerfClass, characteristics,
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00003211 rotationOverride);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003212 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003213
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07003214 // Find hidden physical camera characteristics
3215 for (auto& provider : mProviders) {
3216 for (auto& deviceInfo : provider->mDevices) {
3217 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
3218 if (res != NAME_NOT_FOUND) return res;
3219 }
3220 }
3221
3222 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003223}
3224
3225void CameraProviderManager::filterLogicalCameraIdsLocked(
3226 std::vector<std::string>& deviceIds) const
3227{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003228 // Map between camera facing and camera IDs related to logical camera.
3229 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003230
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003231 // Collect all logical and its underlying physical camera IDs for each
3232 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003233 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07003234 auto deviceInfo = findDeviceInfoLocked(deviceId);
3235 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003236
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07003237 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003238 continue;
3239 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003240
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003241 // combo contains the ids of a logical camera and its physical cameras
3242 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
3243 combo.push_back(deviceId);
3244
3245 hardware::CameraInfo info;
Austin Borger18b30a72022-10-27 12:20:29 -07003246 int portraitRotation;
Jayant Chowdhary81d81b02024-02-15 19:13:39 +00003247 status_t res = deviceInfo->getCameraInfo(
3248 /*rotationOverride*/hardware::ICameraService::ROTATION_OVERRIDE_NONE,
3249 &portraitRotation, &info);
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003250 if (res != OK) {
3251 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
3252 continue;
3253 }
3254 idCombos[info.facing].insert(combo.begin(), combo.end());
3255 }
3256
3257 // Only expose one camera ID per facing for all logical and underlying
3258 // physical camera IDs.
3259 for (auto& r : idCombos) {
3260 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003261 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003262 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
3263 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003264 continue;
3265 }
3266
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003267 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003268 break;
3269 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07003270 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
3271 [&removedIds](const std::string& s) {
3272 return removedIds.find(s) != removedIds.end();}),
3273 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003274 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07003275}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08003276
Vadim Caen7eccd7c2023-10-03 16:26:33 +02003277bool CameraProviderManager::isVirtualCameraHalEnabled() {
Jan Sebechlebsky2f66b5e2024-01-16 17:00:26 +01003278 return vd_flags::virtual_camera_service_discovery() &&
3279 vd_flags::virtual_camera_service_build_flag();
Vadim Caen7eccd7c2023-10-03 16:26:33 +02003280}
3281
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08003282} // namespace android