blob: 23f78842f7b183e03b48ce14bec2a20c8bef1e47 [file] [log] [blame]
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "CameraProviderManager"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include "CameraProviderManager.h"
22
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070023#include <android/hardware/camera/device/3.5/ICameraDevice.h>
24
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080025#include <algorithm>
Yin-Chia Yeh65405092017-01-13 15:42:28 -080026#include <chrono>
Emilian Peevcbf174b2019-01-25 14:38:59 -080027#include "common/DepthPhotoProcessor.h"
28#include <dlfcn.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070029#include <future>
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070030#include <inttypes.h>
Shuzhen Wangf9d2c022018-08-21 12:07:35 -070031#include <hardware/camera_common.h>
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070032#include <android/hidl/manager/1.2/IServiceManager.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080033#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000034#include <functional>
35#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080036#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070037#include <android-base/logging.h>
38#include <cutils/properties.h>
39#include <hwbinder/IPCThreadState.h>
40#include <utils/Trace.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080041
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080042#include "api2/HeicCompositeStream.h"
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -080043#include "device3/ZoomRatioMapper.h"
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080044
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080045namespace android {
46
47using namespace ::android::hardware::camera;
48using namespace ::android::hardware::camera::common::V1_0;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070049using std::literals::chrono_literals::operator""s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080050
51namespace {
Peter Kalauskasa29c1352018-10-10 12:05:42 -070052const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080053} // anonymous namespace
54
Emilian Peev538c90e2018-12-17 18:03:19 +000055const float CameraProviderManager::kDepthARTolerance = .1f;
56
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080057CameraProviderManager::HardwareServiceInteractionProxy
58CameraProviderManager::sHardwareServiceInteractionProxy{};
59
60CameraProviderManager::~CameraProviderManager() {
61}
62
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070063hardware::hidl_vec<hardware::hidl_string>
64CameraProviderManager::HardwareServiceInteractionProxy::listServices() {
65 hardware::hidl_vec<hardware::hidl_string> ret;
66 auto manager = hardware::defaultServiceManager1_2();
67 if (manager != nullptr) {
68 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
69 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
70 ret = registered;
71 });
72 }
73 return ret;
74}
75
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080076status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
77 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080078 std::lock_guard<std::mutex> lock(mInterfaceMutex);
79 if (proxy == nullptr) {
80 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
81 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080082 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080083 mListener = listener;
84 mServiceProxy = proxy;
Eino-Ville Talvala63f36112018-12-06 14:57:03 -080085 mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
86 provider::V2_5::DeviceState::NORMAL);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080087
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080088 // Registering will trigger notifications for all already-known providers
89 bool success = mServiceProxy->registerForNotifications(
90 /* instance name, empty means no filter */ "",
91 this);
92 if (!success) {
93 ALOGE("%s: Unable to register with hardware service manager for notifications "
94 "about camera providers", __FUNCTION__);
95 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080096 }
Emilian Peev5d7e5152017-02-22 15:37:48 +000097
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070098
99 for (const auto& instance : mServiceProxy->listServices()) {
100 this->addProviderLocked(instance);
101 }
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800102
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700103 IPCThreadState::self()->flushCommands();
104
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800105 return OK;
106}
107
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700108std::pair<int, int> CameraProviderManager::getCameraCount() const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800109 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700110 int systemCameraCount = 0;
111 int publicCameraCount = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800112 for (auto& provider : mProviders) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700113 for (auto &id : provider->mUniqueCameraIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700114 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
115 if (getSystemCameraKindLocked(id, &deviceKind) != OK) {
116 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, id.c_str());
117 continue;
118 }
119 switch(deviceKind) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700120 case SystemCameraKind::PUBLIC:
121 publicCameraCount++;
122 break;
123 case SystemCameraKind::SYSTEM_ONLY_CAMERA:
124 systemCameraCount++;
125 break;
126 default:
127 break;
128 }
129 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800130 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700131 return std::make_pair(systemCameraCount, publicCameraCount);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800132}
133
134std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
135 std::lock_guard<std::mutex> lock(mInterfaceMutex);
136 std::vector<std::string> deviceIds;
137 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700138 for (auto& id : provider->mUniqueCameraIds) {
139 deviceIds.push_back(id);
140 }
141 }
142 return deviceIds;
143}
144
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700145void CameraProviderManager::collectDeviceIdsLocked(const std::vector<std::string> deviceIds,
146 std::vector<std::string>& publicDeviceIds,
147 std::vector<std::string>& systemDeviceIds) const {
148 for (auto &deviceId : deviceIds) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700149 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
150 if (getSystemCameraKindLocked(deviceId, &deviceKind) != OK) {
151 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, deviceId.c_str());
152 continue;
153 }
154 if (deviceKind == SystemCameraKind::SYSTEM_ONLY_CAMERA) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700155 systemDeviceIds.push_back(deviceId);
156 } else {
157 publicDeviceIds.push_back(deviceId);
158 }
159 }
160}
161
Emilian Peevf53f66e2017-04-11 14:29:43 +0100162std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700163 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700164 std::vector<std::string> publicDeviceIds;
165 std::vector<std::string> systemDeviceIds;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700166 std::vector<std::string> deviceIds;
167 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700168 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700169 // Secure cameras should not be exposed through camera 1 api
170 providerDeviceIds.erase(std::remove_if(providerDeviceIds.begin(), providerDeviceIds.end(),
171 [this](const std::string& s) {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700172 SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
173 if (getSystemCameraKindLocked(s, &deviceKind) != OK) {
174 ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, s.c_str());
175 return true;
176 }
177 return deviceKind == SystemCameraKind::HIDDEN_SECURE_CAMERA;}),
178 providerDeviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700179 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700180 // for each camera facing, only take the first id advertised by HAL in
181 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700182 filterLogicalCameraIdsLocked(providerDeviceIds);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700183 collectDeviceIdsLocked(providerDeviceIds, publicDeviceIds, systemDeviceIds);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800184 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700185 auto sortFunc =
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800186 [](const std::string& a, const std::string& b) -> bool {
187 uint32_t aUint = 0, bUint = 0;
188 bool aIsUint = base::ParseUint(a, &aUint);
189 bool bIsUint = base::ParseUint(b, &bUint);
190
191 // Uint device IDs first
192 if (aIsUint && bIsUint) {
193 return aUint < bUint;
194 } else if (aIsUint) {
195 return true;
196 } else if (bIsUint) {
197 return false;
198 }
199 // Simple string compare if both id are not uint
200 return a < b;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700201 };
202 // We put device ids for system cameras at the end since they will be pared
203 // off for processes not having system camera permissions.
204 std::sort(publicDeviceIds.begin(), publicDeviceIds.end(), sortFunc);
205 std::sort(systemDeviceIds.begin(), systemDeviceIds.end(), sortFunc);
206 deviceIds.insert(deviceIds.end(), publicDeviceIds.begin(), publicDeviceIds.end());
207 deviceIds.insert(deviceIds.end(), systemDeviceIds.begin(), systemDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800208 return deviceIds;
209}
210
211bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
212 std::lock_guard<std::mutex> lock(mInterfaceMutex);
213 return isValidDeviceLocked(id, majorVersion);
214}
215
216bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
217 for (auto& provider : mProviders) {
218 for (auto& deviceInfo : provider->mDevices) {
219 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
220 return true;
221 }
222 }
223 }
224 return false;
225}
226
227bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
228 std::lock_guard<std::mutex> lock(mInterfaceMutex);
229
230 auto deviceInfo = findDeviceInfoLocked(id);
231 if (deviceInfo == nullptr) return false;
232
233 return deviceInfo->hasFlashUnit();
234}
235
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800236bool CameraProviderManager::supportNativeZoomRatio(const std::string &id) const {
237 std::lock_guard<std::mutex> lock(mInterfaceMutex);
238
239 auto deviceInfo = findDeviceInfoLocked(id);
240 if (deviceInfo == nullptr) return false;
241
242 return deviceInfo->supportNativeZoomRatio();
243}
244
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800245status_t CameraProviderManager::getResourceCost(const std::string &id,
246 CameraResourceCost* cost) const {
247 std::lock_guard<std::mutex> lock(mInterfaceMutex);
248
249 auto deviceInfo = findDeviceInfoLocked(id);
250 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
251
252 *cost = deviceInfo->mResourceCost;
253 return OK;
254}
255
256status_t CameraProviderManager::getCameraInfo(const std::string &id,
257 hardware::CameraInfo* info) const {
258 std::lock_guard<std::mutex> lock(mInterfaceMutex);
259
260 auto deviceInfo = findDeviceInfoLocked(id);
261 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
262
263 return deviceInfo->getCameraInfo(info);
264}
265
Emilian Peev35ae8262018-11-08 13:11:32 +0000266status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
267 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
268 bool *status /*out*/) const {
269 std::lock_guard<std::mutex> lock(mInterfaceMutex);
270
271 auto deviceInfo = findDeviceInfoLocked(id);
272 if (deviceInfo == nullptr) {
273 return NAME_NOT_FOUND;
274 }
275
276 return deviceInfo->isSessionConfigurationSupported(configuration, status);
277}
278
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800279status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
280 CameraMetadata* characteristics) const {
281 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700282 return getCameraCharacteristicsLocked(id, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800283}
284
285status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
286 hardware::hidl_version *v) {
287 std::lock_guard<std::mutex> lock(mInterfaceMutex);
288
289 hardware::hidl_version maxVersion{0,0};
290 bool found = false;
291 for (auto& provider : mProviders) {
292 for (auto& deviceInfo : provider->mDevices) {
293 if (deviceInfo->mId == id) {
294 if (deviceInfo->mVersion > maxVersion) {
295 maxVersion = deviceInfo->mVersion;
296 found = true;
297 }
298 }
299 }
300 }
301 if (!found) {
302 return NAME_NOT_FOUND;
303 }
304 *v = maxVersion;
305 return OK;
306}
307
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700308bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700309 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700310 for (auto& provider : mProviders) {
311 auto deviceInfo = findDeviceInfoLocked(id);
312 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700313 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700314 }
315 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700316 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700317}
318
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800319status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
320 std::lock_guard<std::mutex> lock(mInterfaceMutex);
321
322 auto deviceInfo = findDeviceInfoLocked(id);
323 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
324
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700325 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
326 // that are currently in use.
327 const sp<provider::V2_4::ICameraProvider> interface =
328 deviceInfo->mParentProvider->startProviderInterface();
329 if (interface == nullptr) {
330 return DEAD_OBJECT;
331 }
332 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
333
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800334 return deviceInfo->setTorchMode(enabled);
335}
336
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800337status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000338 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
339
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800340 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800341 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800342 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000343
344 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
345
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800346 return OK;
347}
348
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800349status_t CameraProviderManager::notifyDeviceStateChange(
350 hardware::hidl_bitfield<provider::V2_5::DeviceState> newState) {
351 std::lock_guard<std::mutex> lock(mInterfaceMutex);
352 mDeviceState = newState;
353 status_t res = OK;
354 for (auto& provider : mProviders) {
355 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
356 __FUNCTION__, provider->mProviderName.c_str(), newState);
357 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
358 if (singleRes != OK) {
359 ALOGE("%s: Unable to notify provider %s about device state change",
360 __FUNCTION__,
361 provider->mProviderName.c_str());
362 res = singleRes;
363 // continue to do the rest of the providers instead of returning now
364 }
365 }
366 return res;
367}
368
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800369status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800370 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800371 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800372 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800373
374 std::lock_guard<std::mutex> lock(mInterfaceMutex);
375
376 auto deviceInfo = findDeviceInfoLocked(id,
377 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
378 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
379
380 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700381 const sp<provider::V2_4::ICameraProvider> provider =
382 deviceInfo->mParentProvider->startProviderInterface();
383 if (provider == nullptr) {
384 return DEAD_OBJECT;
385 }
386 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800387
388 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700389 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700390 auto interface = deviceInfo3->startDeviceInterface<
391 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
392 if (interface == nullptr) {
393 return DEAD_OBJECT;
394 }
395
396 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800397 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
398 status = s;
399 if (status == Status::OK) {
400 *session = cameraSession;
401 }
402 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700403 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700404 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700405 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
406 __FUNCTION__, id.c_str(), ret.description().c_str());
407 return DEAD_OBJECT;
408 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800409 return mapToStatusT(status);
410}
411
412status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800413 const sp<device::V1_0::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800414 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800415 sp<device::V1_0::ICameraDevice> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800416
417 std::lock_guard<std::mutex> lock(mInterfaceMutex);
418
419 auto deviceInfo = findDeviceInfoLocked(id,
420 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
421 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
422
423 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700424 const sp<provider::V2_4::ICameraProvider> provider =
425 deviceInfo->mParentProvider->startProviderInterface();
426 if (provider == nullptr) {
427 return DEAD_OBJECT;
428 }
429 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800430
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700431 auto interface = deviceInfo1->startDeviceInterface<
432 CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT>();
433 if (interface == nullptr) {
434 return DEAD_OBJECT;
435 }
436 hardware::Return<Status> status = interface->open(callback);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700437 if (!status.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700438 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700439 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
440 __FUNCTION__, id.c_str(), status.description().c_str());
441 return DEAD_OBJECT;
442 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800443 if (status == Status::OK) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700444 *session = interface;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800445 }
446 return mapToStatusT(status);
447}
448
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700449void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
450 sp<provider::V2_4::ICameraProvider> provider) {
451 if (!kEnableLazyHal) {
452 return;
453 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800454 ALOGV("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700455 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
456 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
457 if (usageType == DeviceMode::TORCH) {
458 primaryMap = &mTorchProviderByCameraId;
459 alternateMap = &mCameraProviderByCameraId;
460 } else {
461 primaryMap = &mCameraProviderByCameraId;
462 alternateMap = &mTorchProviderByCameraId;
463 }
464 auto id = cameraId.c_str();
465 (*primaryMap)[id] = provider;
466 auto search = alternateMap->find(id);
467 if (search != alternateMap->end()) {
468 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
469 "That should not be possible", __FUNCTION__, id);
470 }
471 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
472}
473
474void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
475 if (!kEnableLazyHal) {
476 return;
477 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800478 ALOGV("Removing camera device %s", cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700479 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
480 if (usageType == DeviceMode::TORCH) {
481 providerMap = &mTorchProviderByCameraId;
482 } else {
483 providerMap = &mCameraProviderByCameraId;
484 }
485 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
486 auto search = providerMap->find(cameraId.c_str());
487 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800488 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
489 // added delay) because hwservicemanager guarantees to hold the reference for at least five
490 // more seconds. We depend on this behavior so that if the provider is unreferenced and
491 // then referenced again quickly, we do not let the HAL exit and then need to immediately
492 // restart it. An example when this could happen is switching from a front-facing to a
493 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
494 // appear janky to the user.
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700495 providerMap->erase(cameraId.c_str());
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800496 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700497 } else {
498 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
499 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
500 cameraId.c_str());
501 }
502}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800503
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800504hardware::Return<void> CameraProviderManager::onRegistration(
505 const hardware::hidl_string& /*fqName*/,
506 const hardware::hidl_string& name,
507 bool /*preexisting*/) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700508 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100509 {
510 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800511
Emilian Peevaee727d2017-05-04 16:35:48 +0100512 addProviderLocked(name);
513 }
514
515 sp<StatusListener> listener = getStatusListener();
516 if (nullptr != listener.get()) {
517 listener->onNewProviderRegistered();
518 }
519
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700520 IPCThreadState::self()->flushCommands();
521
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800522 return hardware::Return<void>();
523}
524
525status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
526 std::lock_guard<std::mutex> lock(mInterfaceMutex);
527
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800528 for (auto& provider : mProviders) {
529 provider->dump(fd, args);
530 }
531 return OK;
532}
533
534CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800535 const std::string& id,
536 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800537 for (auto& provider : mProviders) {
538 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800539 if (deviceInfo->mId == id &&
540 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800541 return deviceInfo.get();
542 }
543 }
544 }
545 return nullptr;
546}
547
Emilian Peev71c73a22017-03-21 16:35:51 +0000548metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
549 const std::string& id, hardware::hidl_version minVersion,
550 hardware::hidl_version maxVersion) const {
551 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
552
553 std::lock_guard<std::mutex> lock(mInterfaceMutex);
554 for (auto& provider : mProviders) {
555 for (auto& deviceInfo : provider->mDevices) {
556 if (deviceInfo->mId == id &&
557 minVersion <= deviceInfo->mVersion &&
558 maxVersion >= deviceInfo->mVersion) {
559 return provider->mProviderTagid;
560 }
561 }
562 }
563
564 return ret;
565}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800566
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700567void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
568 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700569
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700570 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700571 for (size_t i = 0; i < entryCap.count; ++i) {
572 uint8_t capability = entryCap.data.u8[i];
573 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700574 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700575 break;
576 }
577 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700578 if (!mIsLogicalCamera) {
579 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700580 }
581
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700582 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
583 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700584 const uint8_t* ids = entryIds.data.u8;
585 size_t start = 0;
586 for (size_t i = 0; i < entryIds.count; ++i) {
587 if (ids[i] == '\0') {
588 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700589 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700590 }
591 start = i+1;
592 }
593 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700594}
595
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700596SystemCameraKind CameraProviderManager::ProviderInfo::DeviceInfo3::getSystemCameraKind() {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800597 camera_metadata_entry_t entryCap;
598 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700599 if (entryCap.count == 1 &&
600 entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
601 return SystemCameraKind::HIDDEN_SECURE_CAMERA;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800602 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700603
604 // Go through the capabilities and check if it has
605 // ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA
606 for (size_t i = 0; i < entryCap.count; ++i) {
607 uint8_t capability = entryCap.data.u8[i];
608 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA) {
609 return SystemCameraKind::SYSTEM_ONLY_CAMERA;
610 }
611 }
612 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800613}
614
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000615void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
616 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
617 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
618 if (sizes == nullptr) {
619 return;
620 }
621
622 auto scalerDims = ch.find(tag);
623 if (scalerDims.count > 0) {
624 // Scaler entry contains 4 elements (format, width, height, type)
625 for (size_t i = 0; i < scalerDims.count; i += 4) {
626 if ((scalerDims.data.i32[i] == format) &&
627 (scalerDims.data.i32[i+3] ==
628 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
629 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
630 scalerDims.data.i32[i+2]));
631 }
632 }
633 }
634}
635
636void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
637 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
638 const std::vector<std::tuple<size_t, size_t>>& sizes,
639 std::vector<int64_t> *durations/*out*/) {
640 if (durations == nullptr) {
641 return;
642 }
643
644 auto availableDurations = ch.find(tag);
645 if (availableDurations.count > 0) {
646 // Duration entry contains 4 elements (format, width, height, duration)
647 for (size_t i = 0; i < availableDurations.count; i += 4) {
648 for (const auto& size : sizes) {
649 int64_t width = std::get<0>(size);
650 int64_t height = std::get<1>(size);
651 if ((availableDurations.data.i64[i] == format) &&
652 (availableDurations.data.i64[i+1] == width) &&
653 (availableDurations.data.i64[i+2] == height)) {
654 durations->push_back(availableDurations.data.i64[i+3]);
655 }
656 }
657 }
658 }
659}
660void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
661 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
662 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
663 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
664 return;
665 }
666
667 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
668 // Processing time on camera service side can vary greatly depending on multiple
669 // variables which are not under our control. Make a guesstimate by taking the maximum
670 // corresponding duration value from depth and blob.
671 auto depthDuration = depthDurations.begin();
672 auto blobDuration = blobDurations.begin();
673 dynamicDepthDurations->reserve(depthDurations.size());
674 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
675 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
676 depthDuration++; blobDuration++;
677 }
678}
679
680void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
681 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
682 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
683 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
684 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
685 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
686 return;
687 }
688
689 // The dynamic depth spec. does not mention how close the AR ratio should be.
690 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000691 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000692
693 for (const auto& blobSize : blobSizes) {
694 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
695 static_cast<float>(std::get<1>(blobSize));
696 bool found = false;
697 for (const auto& depthSize : depthSizes) {
698 if (depthSize == blobSize) {
699 internalDepthSizes->push_back(depthSize);
700 found = true;
701 break;
702 } else {
703 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
704 static_cast<float>(std::get<1>(depthSize));
705 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
706 internalDepthSizes->push_back(depthSize);
707 found = true;
708 break;
709 }
710 }
711 }
712
713 if (found) {
714 dynamicDepthSizes->push_back(blobSize);
715 }
716 }
717}
718
Emilian Peevcbf174b2019-01-25 14:38:59 -0800719bool CameraProviderManager::ProviderInfo::DeviceInfo3::isDepthPhotoLibraryPresent() {
720 static bool libraryPresent = false;
721 static bool initialized = false;
722 if (initialized) {
723 return libraryPresent;
724 } else {
725 initialized = true;
726 }
727
728 void* depthLibHandle = dlopen(camera3::kDepthPhotoLibrary, RTLD_NOW | RTLD_LOCAL);
729 if (depthLibHandle == nullptr) {
730 return false;
731 }
732
733 auto processFunc = dlsym(depthLibHandle, camera3::kDepthPhotoProcessFunction);
734 if (processFunc != nullptr) {
735 libraryPresent = true;
736 } else {
737 libraryPresent = false;
738 }
739 dlclose(depthLibHandle);
740
741 return libraryPresent;
742}
743
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000744status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags() {
745 uint32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
746 uint32_t depthSizesTag = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS;
747 auto& c = mCameraCharacteristics;
748 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
749 supportedDynamicDepthSizes, internalDepthSizes;
750 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
751 if (chTags.count == 0) {
752 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
753 return BAD_VALUE;
754 }
755
756 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
757 depthExclTag) != (chTags.data.i32 + chTags.count);
758 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -0800759 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000760 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
761 // No depth support, nothing more to do.
762 return OK;
763 }
764
765 auto depthExclusiveEntry = c.find(depthExclTag);
766 if (depthExclusiveEntry.count > 0) {
767 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
768 // Depth support is exclusive, nothing more to do.
769 return OK;
770 }
771 } else {
772 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
773 return BAD_VALUE;
774 }
775
776 getSupportedSizes(c, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, HAL_PIXEL_FORMAT_BLOB,
777 &supportedBlobSizes);
778 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
779 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
780 // Nothing to do in this case.
781 return OK;
782 }
783
784 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
785 &supportedDynamicDepthSizes, &internalDepthSizes);
786 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000787 // Nothing more to do.
788 return OK;
789 }
790
Emilian Peevcbf174b2019-01-25 14:38:59 -0800791 if(!isDepthPhotoLibraryPresent()) {
792 // Depth photo processing library is not present, nothing more to do.
793 return OK;
794 }
795
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000796 std::vector<int32_t> dynamicDepthEntries;
797 for (const auto& it : supportedDynamicDepthSizes) {
798 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
799 static_cast<int32_t> (std::get<1>(it)),
800 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
801 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
802 }
803
804 std::vector<int64_t> depthMinDurations, depthStallDurations;
805 std::vector<int64_t> blobMinDurations, blobStallDurations;
806 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
807
808 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,
809 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthMinDurations);
810 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
811 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobMinDurations);
812 if (blobMinDurations.empty() || depthMinDurations.empty() ||
813 (depthMinDurations.size() != blobMinDurations.size())) {
814 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
815 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
816 return BAD_VALUE;
817 }
818
819 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS,
820 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthStallDurations);
821 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
822 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobStallDurations);
823 if (blobStallDurations.empty() || depthStallDurations.empty() ||
824 (depthStallDurations.size() != blobStallDurations.size())) {
825 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
826 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
827 return BAD_VALUE;
828 }
829
830 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
831 &dynamicDepthMinDurations);
832 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
833 &dynamicDepthStallDurations);
834 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
835 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
836 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
837 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
838 return BAD_VALUE;
839 }
840
841 std::vector<int64_t> dynamicDepthMinDurationEntries;
842 auto itDuration = dynamicDepthMinDurations.begin();
843 auto itSize = supportedDynamicDepthSizes.begin();
844 while (itDuration != dynamicDepthMinDurations.end()) {
845 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
846 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
847 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
848 entry + 4);
849 itDuration++; itSize++;
850 }
851
852 std::vector<int64_t> dynamicDepthStallDurationEntries;
853 itDuration = dynamicDepthStallDurations.begin();
854 itSize = supportedDynamicDepthSizes.begin();
855 while (itDuration != dynamicDepthStallDurations.end()) {
856 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
857 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
858 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
859 entry + 4);
860 itDuration++; itSize++;
861 }
862
863 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
864 dynamicDepthEntries.data(), dynamicDepthEntries.size());
865 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,
866 dynamicDepthMinDurationEntries.data(), dynamicDepthMinDurationEntries.size());
867 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,
868 dynamicDepthStallDurationEntries.data(), dynamicDepthStallDurationEntries.size());
869
870 std::vector<int32_t> supportedChTags;
871 supportedChTags.reserve(chTags.count + 3);
872 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
873 chTags.data.i32 + chTags.count);
874 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
875 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS);
876 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS);
877 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
878 supportedChTags.size());
879
880 return OK;
881}
882
Shuzhen Wang268a1362018-10-16 16:32:59 -0700883status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
884 status_t res = OK;
885 auto& c = mCameraCharacteristics;
886
887 // Override static metadata for MONOCHROME camera with older device version
888 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
889 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
890 for (size_t i = 0; i < cap.count; i++) {
891 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
892 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
893 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
894 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
895 if (res != OK) {
896 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
897 __FUNCTION__, strerror(-res), res);
898 return res;
899 }
900
901 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
902 const std::vector<uint32_t> sKeys = {
903 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
904 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
905 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
906 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
907 ANDROID_SENSOR_COLOR_TRANSFORM1,
908 ANDROID_SENSOR_COLOR_TRANSFORM2,
909 ANDROID_SENSOR_FORWARD_MATRIX1,
910 ANDROID_SENSOR_FORWARD_MATRIX2,
911 };
912 res = removeAvailableKeys(c, sKeys,
913 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
914 if (res != OK) {
915 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
916 __FUNCTION__, strerror(-res), res);
917 return res;
918 }
919
920 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
921 const std::vector<uint32_t> reqKeys = {
922 ANDROID_COLOR_CORRECTION_MODE,
923 ANDROID_COLOR_CORRECTION_TRANSFORM,
924 ANDROID_COLOR_CORRECTION_GAINS,
925 };
926 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
927 if (res != OK) {
928 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
929 __FUNCTION__, strerror(-res), res);
930 return res;
931 }
932
933 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
934 const std::vector<uint32_t> resKeys = {
935 ANDROID_SENSOR_GREEN_SPLIT,
936 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
937 ANDROID_COLOR_CORRECTION_MODE,
938 ANDROID_COLOR_CORRECTION_TRANSFORM,
939 ANDROID_COLOR_CORRECTION_GAINS,
940 };
941 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
942 if (res != OK) {
943 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
944 __FUNCTION__, strerror(-res), res);
945 return res;
946 }
947
948 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
949 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
950 for (size_t j = 1; j < blEntry.count; j++) {
951 blEntry.data.i32[j] = blEntry.data.i32[0];
952 }
953 }
954 }
955 }
956 return res;
957}
958
959status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
960 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
961 status_t res = OK;
962
963 camera_metadata_entry keysEntry = c.find(keyTag);
964 if (keysEntry.count == 0) {
965 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
966 return res;
967 }
968 std::vector<int32_t> vKeys;
969 vKeys.reserve(keysEntry.count);
970 for (size_t i = 0; i < keysEntry.count; i++) {
971 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
972 vKeys.push_back(keysEntry.data.i32[i]);
973 }
974 }
975 res = c.update(keyTag, vKeys.data(), vKeys.size());
976 return res;
977}
978
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -0800979status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
980 std::vector<int32_t>* outputs,
981 std::vector<int64_t>* durations,
982 std::vector<int64_t>* stallDurations,
983 const camera_metadata_entry& halStreamConfigs,
984 const camera_metadata_entry& halStreamDurations) {
985 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
986 return BAD_VALUE;
987 }
988
989 static bool supportInMemoryTempFile =
990 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
991 if (!supportInMemoryTempFile) {
992 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
993 __FUNCTION__);
994 return OK;
995 }
996
997 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
998 int32_t format = halStreamConfigs.data.i32[i];
999 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
1000 // image.
1001 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
1002 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
1003 continue;
1004 }
1005
1006 bool sizeAvail = false;
1007 for (size_t j = 0; j < outputs->size(); j+= 4) {
1008 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
1009 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
1010 sizeAvail = true;
1011 break;
1012 }
1013 }
1014 if (sizeAvail) continue;
1015
1016 int64_t stall = 0;
1017 bool useHeic, useGrid;
1018 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
1019 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
1020 &useHeic, &useGrid, &stall)) {
1021 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
1022 continue;
1023 }
1024
1025 // HEIC configuration
1026 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1027 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
1028 outputs->insert(outputs->end(), config, config + 4);
1029
1030 // HEIC minFrameDuration
1031 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
1032 if (halStreamDurations.data.i64[j] == format &&
1033 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
1034 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
1035 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1036 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
1037 durations->insert(durations->end(), duration, duration+4);
1038 break;
1039 }
1040 }
1041
1042 // HEIC stallDuration
1043 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1044 halStreamConfigs.data.i32[i+2], stall};
1045 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
1046 }
1047 }
1048 return OK;
1049}
1050
1051status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags() {
1052 auto& c = mCameraCharacteristics;
1053
1054 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
1055 if (halHeicSupport.count > 1) {
1056 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
1057 __FUNCTION__, halHeicSupport.count);
1058 return BAD_VALUE;
1059 } else if (halHeicSupport.count == 0 ||
1060 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
1061 // Camera HAL doesn't support mandatory stream combinations for HEIC.
1062 return OK;
1063 }
1064
1065 camera_metadata_entry maxJpegAppsSegments =
1066 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1067 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1068 maxJpegAppsSegments.data.u8[0] > 16) {
1069 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1070 __FUNCTION__);
1071 return BAD_VALUE;
1072 }
1073
1074 // Populate HEIC output configurations and its related min frame duration
1075 // and stall duration.
1076 std::vector<int32_t> heicOutputs;
1077 std::vector<int64_t> heicDurations;
1078 std::vector<int64_t> heicStallDurations;
1079
1080 camera_metadata_entry halStreamConfigs =
1081 c.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
1082 camera_metadata_entry minFrameDurations =
1083 c.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
1084
1085 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
1086 halStreamConfigs, minFrameDurations);
1087 if (res != OK) {
1088 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
1089 strerror(-res), res);
1090 return res;
1091 }
1092
1093 c.update(ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS,
1094 heicOutputs.data(), heicOutputs.size());
1095 c.update(ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS,
1096 heicDurations.data(), heicDurations.size());
1097 c.update(ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS,
1098 heicStallDurations.data(), heicStallDurations.size());
1099
1100 return OK;
1101}
1102
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001103bool CameraProviderManager::isLogicalCamera(const std::string& id,
1104 std::vector<std::string>* physicalCameraIds) {
1105 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1106
1107 auto deviceInfo = findDeviceInfoLocked(id);
1108 if (deviceInfo == nullptr) return false;
1109
1110 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
1111 *physicalCameraIds = deviceInfo->mPhysicalIds;
1112 }
1113 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001114}
1115
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001116status_t CameraProviderManager::getSystemCameraKind(const std::string& id,
1117 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001118 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001119 return getSystemCameraKindLocked(id, kind);
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001120}
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001121
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001122status_t CameraProviderManager::getSystemCameraKindLocked(const std::string& id,
1123 SystemCameraKind *kind) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001124 auto deviceInfo = findDeviceInfoLocked(id);
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001125 if (deviceInfo != nullptr) {
1126 *kind = deviceInfo->mSystemCameraKind;
1127 return OK;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001128 }
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001129 // If this is a hidden physical camera, we should return what kind of
1130 // camera the enclosing logical camera is.
1131 auto isHiddenAndParent = isHiddenPhysicalCameraInternal(id);
1132 if (isHiddenAndParent.first) {
1133 LOG_ALWAYS_FATAL_IF(id == isHiddenAndParent.second->mId,
1134 "%s: hidden physical camera id %s and enclosing logical camera id %s are the same",
1135 __FUNCTION__, id.c_str(), isHiddenAndParent.second->mId.c_str());
1136 return getSystemCameraKindLocked(isHiddenAndParent.second->mId, kind);
1137 }
1138 // Neither a hidden physical camera nor a logical camera
1139 return NAME_NOT_FOUND;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001140}
1141
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001142bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) const {
1143 return isHiddenPhysicalCameraInternal(cameraId).first;
1144}
1145
1146std::pair<bool, CameraProviderManager::ProviderInfo::DeviceInfo *>
1147CameraProviderManager::isHiddenPhysicalCameraInternal(const std::string& cameraId) const {
1148 auto falseRet = std::make_pair(false, nullptr);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001149 for (auto& provider : mProviders) {
1150 for (auto& deviceInfo : provider->mDevices) {
1151 if (deviceInfo->mId == cameraId) {
1152 // cameraId is found in public camera IDs advertised by the
1153 // provider.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001154 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001155 }
1156 }
1157 }
1158
1159 for (auto& provider : mProviders) {
1160 for (auto& deviceInfo : provider->mDevices) {
1161 CameraMetadata info;
1162 status_t res = deviceInfo->getCameraCharacteristics(&info);
1163 if (res != OK) {
1164 ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
1165 deviceInfo->mId.c_str());
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001166 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001167 }
1168
1169 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001170 if (deviceInfo->mIsLogicalCamera) {
1171 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1172 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001173 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
1174 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
1175 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
1176 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
1177 __FUNCTION__, deviceVersion, cameraId.c_str());
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001178 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001179 } else {
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001180 return std::make_pair(true, deviceInfo.get());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001181 }
1182 }
1183 }
1184 }
1185 }
1186
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -07001187 return falseRet;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001188}
1189
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001190status_t CameraProviderManager::addProviderLocked(const std::string& newProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001191 for (const auto& providerInfo : mProviders) {
1192 if (providerInfo->mProviderName == newProvider) {
1193 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
1194 newProvider.c_str());
1195 return ALREADY_EXISTS;
1196 }
1197 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001198
1199 sp<provider::V2_4::ICameraProvider> interface;
Eino-Ville Talvalaec960602019-10-15 11:46:16 -07001200 interface = mServiceProxy->tryGetService(newProvider);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001201
1202 if (interface == nullptr) {
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001203 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
1204 newProvider.c_str());
1205 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001206 }
1207
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001208 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001209 status_t res = providerInfo->initialize(interface, mDeviceState);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001210 if (res != OK) {
1211 return res;
1212 }
1213
1214 mProviders.push_back(providerInfo);
1215
1216 return OK;
1217}
1218
1219status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07001220 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001221 std::unique_lock<std::mutex> lock(mInterfaceMutex);
1222 std::vector<String8> removedDeviceIds;
1223 status_t res = NAME_NOT_FOUND;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001224 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
1225 if ((*it)->mProviderName == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001226 removedDeviceIds.reserve((*it)->mDevices.size());
1227 for (auto& deviceInfo : (*it)->mDevices) {
1228 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
1229 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001230 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001231 res = OK;
1232 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001233 }
1234 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001235 if (res != OK) {
1236 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1237 provider.c_str());
1238 } else {
1239 // Inform camera service of loss of presence for all the devices from this provider,
1240 // without lock held for reentrancy
1241 sp<StatusListener> listener = getStatusListener();
1242 if (listener != nullptr) {
1243 lock.unlock();
1244 for (auto& id : removedDeviceIds) {
1245 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1246 }
1247 }
1248 }
1249 return res;
1250}
1251
1252sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1253 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001254}
1255
1256/**** Methods for ProviderInfo ****/
1257
1258
1259CameraProviderManager::ProviderInfo::ProviderInfo(
1260 const std::string &providerName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001261 CameraProviderManager *manager) :
1262 mProviderName(providerName),
Emilian Peev71c73a22017-03-21 16:35:51 +00001263 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001264 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001265 mManager(manager) {
1266 (void) mManager;
1267}
1268
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001269status_t CameraProviderManager::ProviderInfo::initialize(
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001270 sp<provider::V2_4::ICameraProvider>& interface,
1271 hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001272 status_t res = parseProviderName(mProviderName, &mType, &mId);
1273 if (res != OK) {
1274 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1275 return BAD_VALUE;
1276 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001277 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001278 mProviderName.c_str(), interface->isRemote());
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001279
1280 // Determine minor version
1281 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1282 if (castResult.isOk()) {
1283 mMinorVersion = 5;
1284 } else {
1285 mMinorVersion = 4;
1286 }
1287
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001288 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1289 // before setCallback returns
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001290 hardware::Return<Status> status = interface->setCallback(this);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001291 if (!status.isOk()) {
1292 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1293 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1294 return DEAD_OBJECT;
1295 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001296 if (status != Status::OK) {
1297 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1298 __FUNCTION__, mProviderName.c_str());
1299 return mapToStatusT(status);
1300 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001301
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001302 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001303 if (!linked.isOk()) {
1304 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1305 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1306 return DEAD_OBJECT;
1307 } else if (!linked) {
1308 ALOGW("%s: Unable to link to provider '%s' death notifications",
1309 __FUNCTION__, mProviderName.c_str());
1310 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001311
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001312 if (!kEnableLazyHal) {
1313 // Save HAL reference indefinitely
1314 mSavedInterface = interface;
1315 } else {
1316 mActiveInterface = interface;
1317 }
1318
1319 ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
1320 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1321 notifyDeviceStateChange(currentDeviceState);
1322
1323 res = setUpVendorTags();
1324 if (res != OK) {
1325 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1326 __FUNCTION__, mProviderName.c_str());
1327 return res;
1328 }
1329
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001330 // Get initial list of camera devices, if any
1331 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001332 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001333 Status idStatus,
1334 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1335 status = idStatus;
1336 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001337 for (auto& name : cameraDeviceNames) {
1338 uint16_t major, minor;
1339 std::string type, id;
1340 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1341 if (res != OK) {
1342 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1343 status = Status::INTERNAL_ERROR;
1344 } else {
1345 devices.push_back(name);
1346 mProviderPublicCameraIds.push_back(id);
1347 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001348 }
1349 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001350 if (!ret.isOk()) {
1351 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1352 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1353 return DEAD_OBJECT;
1354 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001355 if (status != Status::OK) {
1356 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1357 __FUNCTION__, mProviderName.c_str());
1358 return mapToStatusT(status);
1359 }
1360
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001361 ret = interface->isSetTorchModeSupported(
1362 [this](auto status, bool supported) {
1363 if (status == Status::OK) {
1364 mSetTorchModeSupported = supported;
1365 }
1366 });
1367 if (!ret.isOk()) {
1368 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1369 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1370 return DEAD_OBJECT;
1371 }
1372
1373 mIsRemote = interface->isRemote();
1374
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001375 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001376 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001377 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001378 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001379 if (res != OK) {
1380 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1381 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001382 continue;
1383 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001384 }
1385
1386 ALOGI("Camera provider %s ready with %zu camera devices",
1387 mProviderName.c_str(), mDevices.size());
1388
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001389 mInitialized = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001390 return OK;
1391}
1392
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001393const sp<provider::V2_4::ICameraProvider>
1394CameraProviderManager::ProviderInfo::startProviderInterface() {
1395 ATRACE_CALL();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001396 ALOGV("Request to start camera provider: %s", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001397 if (mSavedInterface != nullptr) {
1398 return mSavedInterface;
1399 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001400 if (!kEnableLazyHal) {
1401 ALOGE("Bad provider state! Should not be here on a non-lazy HAL!");
1402 return nullptr;
1403 }
1404
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001405 auto interface = mActiveInterface.promote();
1406 if (interface == nullptr) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001407 ALOGI("Camera HAL provider needs restart, calling getService(%s)", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001408 interface = mManager->mServiceProxy->getService(mProviderName);
1409 interface->setCallback(this);
1410 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
1411 if (!linked.isOk()) {
1412 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1413 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1414 mManager->removeProvider(mProviderName);
1415 return nullptr;
1416 } else if (!linked) {
1417 ALOGW("%s: Unable to link to provider '%s' death notifications",
1418 __FUNCTION__, mProviderName.c_str());
1419 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001420 // Send current device state
1421 if (mMinorVersion >= 5) {
1422 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1423 if (castResult.isOk()) {
1424 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1425 if (interface_2_5 != nullptr) {
1426 ALOGV("%s: Initial device state for %s: 0x %" PRIx64,
1427 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1428 interface_2_5->notifyDeviceStateChange(mDeviceState);
1429 }
1430 }
1431 }
1432
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001433 mActiveInterface = interface;
1434 } else {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001435 ALOGV("Camera provider (%s) already in use. Re-using instance.", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001436 }
1437 return interface;
1438}
1439
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001440const std::string& CameraProviderManager::ProviderInfo::getType() const {
1441 return mType;
1442}
1443
1444status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1445 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1446
1447 ALOGI("Enumerating new camera device: %s", name.c_str());
1448
1449 uint16_t major, minor;
1450 std::string type, id;
1451
1452 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1453 if (res != OK) {
1454 return res;
1455 }
1456 if (type != mType) {
1457 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1458 type.c_str(), mType.c_str());
1459 return BAD_VALUE;
1460 }
1461 if (mManager->isValidDeviceLocked(id, major)) {
1462 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1463 name.c_str(), id.c_str(), major);
1464 return BAD_VALUE;
1465 }
1466
1467 std::unique_ptr<DeviceInfo> deviceInfo;
1468 switch (major) {
1469 case 1:
Emilian Peev71c73a22017-03-21 16:35:51 +00001470 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
1471 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001472 break;
1473 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001474 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1475 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001476 break;
1477 default:
1478 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1479 name.c_str(), major);
1480 return BAD_VALUE;
1481 }
1482 if (deviceInfo == nullptr) return BAD_VALUE;
1483 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001484 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001485
1486 mDevices.push_back(std::move(deviceInfo));
1487
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001488 mUniqueCameraIds.insert(id);
1489 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001490 // addDevice can be called more than once for the same camera id if HAL
1491 // supports openLegacy.
1492 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1493 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1494 mUniqueAPI1CompatibleCameraIds.push_back(id);
1495 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001496 }
1497
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001498 if (parsedId != nullptr) {
1499 *parsedId = id;
1500 }
1501 return OK;
1502}
1503
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001504void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1505 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1506 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001507 mUniqueCameraIds.erase(id);
1508 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001509 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
1510 mUniqueAPI1CompatibleCameraIds.begin(),
1511 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001512 }
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001513 mDevices.erase(it);
1514 break;
1515 }
1516 }
1517}
1518
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001519status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001520 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
1521 mProviderName.c_str(),
1522 mMinorVersion,
1523 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001524 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001525
1526 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001527 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1528 device->mVersion.get_major(), device->mVersion.get_minor());
1529 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1530 if (device->mResourceCost.conflictingDevices.size() == 0) {
1531 dprintf(fd, " Conflicting devices: None\n");
1532 } else {
1533 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001534 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001535 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001536 device->mResourceCost.conflictingDevices[i].c_str());
1537 }
1538 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001539 dprintf(fd, " API1 info:\n");
1540 dprintf(fd, " Has a flash unit: %s\n",
1541 device->hasFlashUnit() ? "true" : "false");
1542 hardware::CameraInfo info;
1543 status_t res = device->getCameraInfo(&info);
1544 if (res != OK) {
1545 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1546 strerror(-res), res);
1547 } else {
1548 dprintf(fd, " Facing: %s\n",
1549 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1550 dprintf(fd, " Orientation: %d\n", info.orientation);
1551 }
1552 CameraMetadata info2;
1553 res = device->getCameraCharacteristics(&info2);
1554 if (res == INVALID_OPERATION) {
1555 dprintf(fd, " API2 not directly supported\n");
1556 } else if (res != OK) {
1557 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1558 strerror(-res), res);
1559 } else {
1560 dprintf(fd, " API2 camera characteristics:\n");
1561 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1562 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001563
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001564 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001565 if (device->mIsLogicalCamera) {
1566 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001567 // Skip if physical id is an independent camera
1568 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1569 != mProviderPublicCameraIds.end()) {
1570 continue;
1571 }
1572
1573 CameraMetadata physicalInfo;
1574 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1575 if (status == OK) {
1576 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1577 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1578 }
1579 }
1580 }
1581
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001582 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1583 device->mVersion.get_major(), device->mVersion.get_minor());
1584 res = device->dumpState(fd);
1585 if (res != OK) {
1586 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1587 device->mName.c_str(), strerror(-res), res);
1588 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001589 }
1590 return OK;
1591}
1592
1593hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1594 const hardware::hidl_string& cameraDeviceName,
1595 CameraDeviceStatus newStatus) {
1596 sp<StatusListener> listener;
1597 std::string id;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001598 bool initialized = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001599 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001600 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001601 bool known = false;
1602 for (auto& deviceInfo : mDevices) {
1603 if (deviceInfo->mName == cameraDeviceName) {
1604 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
1605 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
1606 deviceInfo->mStatus = newStatus;
1607 // TODO: Handle device removal (NOT_PRESENT)
1608 id = deviceInfo->mId;
1609 known = true;
1610 break;
1611 }
1612 }
1613 // Previously unseen device; status must not be NOT_PRESENT
1614 if (!known) {
1615 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1616 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
1617 mProviderName.c_str(), cameraDeviceName.c_str());
1618 return hardware::Void();
1619 }
1620 addDevice(cameraDeviceName, newStatus, &id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001621 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1622 removeDevice(id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001623 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001624 listener = mManager->getStatusListener();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001625 initialized = mInitialized;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001626 }
1627 // Call without lock held to allow reentrancy into provider manager
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001628 // Don't send the callback if providerInfo hasn't been initialized.
1629 // CameraService will initialize device status after provider is
1630 // initialized
1631 if (listener != nullptr && initialized) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001632 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
1633 }
1634 return hardware::Void();
1635}
1636
1637hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
1638 const hardware::hidl_string& cameraDeviceName,
1639 TorchModeStatus newStatus) {
1640 sp<StatusListener> listener;
1641 std::string id;
1642 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001643 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001644 bool known = false;
1645 for (auto& deviceInfo : mDevices) {
1646 if (deviceInfo->mName == cameraDeviceName) {
1647 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
1648 torchStatusToString(newStatus));
1649 id = deviceInfo->mId;
1650 known = true;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001651 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
1652 mManager->removeRef(DeviceMode::TORCH, id);
1653 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001654 break;
1655 }
1656 }
1657 if (!known) {
1658 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
1659 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
1660 return hardware::Void();
1661 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001662 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001663 }
1664 // Call without lock held to allow reentrancy into provider manager
1665 if (listener != nullptr) {
1666 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
1667 }
1668 return hardware::Void();
1669}
1670
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001671void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
1672 const wp<hidl::base::V1_0::IBase>& who) {
1673 (void) who;
1674 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
1675 if (cookie != mId) {
1676 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
1677 __FUNCTION__, cookie, mId);
1678 }
1679 mManager->removeProvider(mProviderName);
1680}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001681
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001682status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
1683 if (mVendorTagDescriptor != nullptr)
1684 return OK;
1685
1686 hardware::hidl_vec<VendorTagSection> vts;
1687 Status status;
1688 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001689 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1690 if (interface == nullptr) {
1691 return DEAD_OBJECT;
1692 }
1693 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001694 [&](auto s, const auto& vendorTagSecs) {
1695 status = s;
1696 if (s == Status::OK) {
1697 vts = vendorTagSecs;
1698 }
1699 });
1700 if (!ret.isOk()) {
1701 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
1702 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1703 return DEAD_OBJECT;
1704 }
1705 if (status != Status::OK) {
1706 return mapToStatusT(status);
1707 }
1708
1709 // Read all vendor tag definitions into a descriptor
1710 status_t res;
1711 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
1712 != OK) {
1713 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
1714 "received error %s (%d). Camera clients will not be able to use"
1715 "vendor tags", __FUNCTION__, strerror(res), res);
1716 return res;
1717 }
1718
1719 return OK;
1720}
1721
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001722status_t CameraProviderManager::ProviderInfo::notifyDeviceStateChange(
1723 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
1724 mDeviceState = newDeviceState;
1725 if (mMinorVersion >= 5) {
1726 // Check if the provider is currently active - not going to start it up for this notification
1727 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
1728 if (interface != nullptr) {
1729 // Send current device state
1730 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1731 if (castResult.isOk()) {
1732 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1733 if (interface_2_5 != nullptr) {
1734 interface_2_5->notifyDeviceStateChange(mDeviceState);
1735 }
1736 }
1737 }
1738 }
1739 return OK;
1740}
1741
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001742template<class DeviceInfoT>
1743std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
1744 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00001745 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001746 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001747 Status status;
1748
1749 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001750 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001751 if (cameraInterface == nullptr) return nullptr;
1752
1753 CameraResourceCost resourceCost;
1754 cameraInterface->getResourceCost([&status, &resourceCost](
1755 Status s, CameraResourceCost cost) {
1756 status = s;
1757 resourceCost = cost;
1758 });
1759 if (status != Status::OK) {
1760 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
1761 name.c_str(), statusToString(status));
1762 return nullptr;
1763 }
Shuzhen Wang47283692018-04-24 18:05:02 -07001764
1765 for (auto& conflictName : resourceCost.conflictingDevices) {
1766 uint16_t major, minor;
1767 std::string type, id;
1768 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
1769 if (res != OK) {
1770 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
1771 return nullptr;
1772 }
1773 conflictName = id;
1774 }
1775
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001776 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001777 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001778 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001779}
1780
1781template<class InterfaceT>
1782sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001783CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001784 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1785 name.c_str(), InterfaceT::version.get_major());
1786 return nullptr;
1787}
1788
1789template<>
1790sp<device::V1_0::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001791CameraProviderManager::ProviderInfo::startDeviceInterface
1792 <device::V1_0::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001793 Status status;
1794 sp<device::V1_0::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001795 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001796 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1797 if (interface == nullptr) {
1798 return nullptr;
1799 }
1800 ret = interface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001801 Status s, sp<device::V1_0::ICameraDevice> interface) {
1802 status = s;
1803 cameraInterface = interface;
1804 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001805 if (!ret.isOk()) {
1806 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1807 __FUNCTION__, name.c_str(), ret.description().c_str());
1808 return nullptr;
1809 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001810 if (status != Status::OK) {
1811 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1812 name.c_str(), statusToString(status));
1813 return nullptr;
1814 }
1815 return cameraInterface;
1816}
1817
1818template<>
1819sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001820CameraProviderManager::ProviderInfo::startDeviceInterface
1821 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001822 Status status;
1823 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001824 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001825 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1826 if (interface == nullptr) {
1827 return nullptr;
1828 }
1829 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001830 Status s, sp<device::V3_2::ICameraDevice> interface) {
1831 status = s;
1832 cameraInterface = interface;
1833 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001834 if (!ret.isOk()) {
1835 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1836 __FUNCTION__, name.c_str(), ret.description().c_str());
1837 return nullptr;
1838 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001839 if (status != Status::OK) {
1840 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1841 name.c_str(), statusToString(status));
1842 return nullptr;
1843 }
1844 return cameraInterface;
1845}
1846
1847CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
1848
1849template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001850sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
1851 sp<InterfaceT> device;
1852 ATRACE_CALL();
1853 if (mSavedInterface == nullptr) {
1854 device = mParentProvider->startDeviceInterface<InterfaceT>(mName);
1855 } else {
1856 device = (InterfaceT *) mSavedInterface.get();
1857 }
1858 return device;
1859}
1860
1861template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001862status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
1863 bool enabled) {
1864 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
1865 return mapToStatusT(s);
1866}
1867
1868CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001869 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001870 uint16_t minorVersion,
1871 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001872 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001873 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001874 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001875 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001876 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001877 // Get default parameters and initialize flash unit availability
1878 // Requires powering on the camera device
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001879 hardware::Return<Status> status = interface->open(nullptr);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001880 if (!status.isOk()) {
1881 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001882 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001883 return;
1884 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001885 if (status != Status::OK) {
1886 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001887 id.c_str(), CameraProviderManager::statusToString(status));
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001888 return;
1889 }
1890 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001891 ret = interface->getParameters([this](const hardware::hidl_string& parms) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001892 mDefaultParameters.unflatten(String8(parms.c_str()));
1893 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001894 if (!ret.isOk()) {
1895 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001896 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001897 return;
1898 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001899 const char *flashMode =
1900 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1901 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
1902 mHasFlashUnit = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001903 }
1904
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001905 status_t res = cacheCameraInfo(interface);
1906 if (res != OK) {
1907 ALOGE("%s: Could not cache CameraInfo", __FUNCTION__);
1908 return;
1909 }
1910
1911 ret = interface->close();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001912 if (!ret.isOk()) {
1913 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001914 __FUNCTION__, id.c_str(), status.description().c_str());
1915 }
1916
1917 if (!kEnableLazyHal) {
1918 // Save HAL reference indefinitely
1919 mSavedInterface = interface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001920 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001921}
1922
1923CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
1924
1925status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001926 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001927}
1928
1929status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
1930 hardware::CameraInfo *info) const {
1931 if (info == nullptr) return BAD_VALUE;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001932 *info = mInfo;
1933 return OK;
1934}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001935
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001936status_t CameraProviderManager::ProviderInfo::DeviceInfo1::cacheCameraInfo(
1937 sp<CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT> interface) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001938 Status status;
1939 device::V1_0::CameraInfo cInfo;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001940 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001941 ret = interface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001942 status = s;
1943 cInfo = camInfo;
1944 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001945 if (!ret.isOk()) {
1946 ALOGE("%s: Transaction error reading camera info from device %s: %s",
1947 __FUNCTION__, mId.c_str(), ret.description().c_str());
1948 return DEAD_OBJECT;
1949 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001950 if (status != Status::OK) {
1951 return mapToStatusT(status);
1952 }
1953
1954 switch(cInfo.facing) {
1955 case device::V1_0::CameraFacing::BACK:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001956 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001957 break;
1958 case device::V1_0::CameraFacing::EXTERNAL:
1959 // Map external to front for legacy API
1960 case device::V1_0::CameraFacing::FRONT:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001961 mInfo.facing = hardware::CAMERA_FACING_FRONT;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001962 break;
1963 default:
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001964 ALOGW("%s: Device %s: Unknown camera facing: %d",
1965 __FUNCTION__, mId.c_str(), cInfo.facing);
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001966 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001967 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001968 mInfo.orientation = cInfo.orientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001969
1970 return OK;
1971}
1972
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001973status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001974 native_handle_t* handle = native_handle_create(1,0);
1975 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001976 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1977 if (interface == nullptr) {
1978 return DEAD_OBJECT;
1979 }
1980 hardware::Return<Status> s = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001981 native_handle_delete(handle);
1982 if (!s.isOk()) {
1983 return INVALID_OPERATION;
1984 }
1985 return mapToStatusT(s);
1986}
1987
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001988CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001989 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001990 uint16_t minorVersion,
1991 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001992 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001993 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001994 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001995 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001996 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001997 // Get camera characteristics and initialize flash unit availability
1998 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001999 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002000 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002001 device::V3_2::CameraMetadata metadata) {
2002 status = s;
2003 if (s == Status::OK) {
2004 camera_metadata_t *buffer =
2005 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07002006 size_t expectedSize = metadata.size();
2007 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2008 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2009 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2010 mCameraCharacteristics = buffer;
2011 } else {
2012 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2013 status = Status::INTERNAL_ERROR;
2014 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002015 }
2016 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002017 if (!ret.isOk()) {
2018 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002019 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07002020 ret.description().c_str());
2021 return;
2022 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002023 if (status != Status::OK) {
2024 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002025 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002026 return;
2027 }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002028
Jayant Chowdhary5216b212019-07-17 09:26:23 -07002029 mSystemCameraKind = getSystemCameraKind();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002030
Shuzhen Wang268a1362018-10-16 16:32:59 -07002031 status_t res = fixupMonochromeTags();
2032 if (OK != res) {
2033 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
2034 __FUNCTION__, strerror(-res), res);
2035 return;
2036 }
Emilian Peeva1185162019-01-30 16:41:43 -08002037 auto stat = addDynamicDepthTags();
2038 if (OK != stat) {
2039 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-stat),
2040 stat);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00002041 }
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08002042 res = deriveHeicTags();
2043 if (OK != res) {
2044 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities: %s (%d)",
2045 __FUNCTION__, strerror(-res), res);
2046 }
2047
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08002048 res = camera3::ZoomRatioMapper::overrideZoomRatioTags(
2049 &mCameraCharacteristics, &mSupportNativeZoomRatio);
2050 if (OK != res) {
2051 ALOGE("%s: Unable to override zoomRatio related tags: %s (%d)",
2052 __FUNCTION__, strerror(-res), res);
2053 }
2054
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002055 camera_metadata_entry flashAvailable =
2056 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
2057 if (flashAvailable.count == 1 &&
2058 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
2059 mHasFlashUnit = true;
2060 } else {
2061 mHasFlashUnit = false;
2062 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002063
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002064 queryPhysicalCameraIds();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002065
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002066 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002067 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002068 if (!castResult.isOk()) {
2069 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
2070 return;
2071 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002072 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002073 if (interface_3_5 == nullptr) {
2074 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
2075 return;
2076 }
2077
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002078 if (mIsLogicalCamera) {
2079 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002080 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
2081 mPublicCameraIds.end()) {
2082 continue;
2083 }
2084
2085 hardware::hidl_string hidlId(id);
2086 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
2087 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
2088 status = s;
2089 if (s == Status::OK) {
2090 camera_metadata_t *buffer =
2091 reinterpret_cast<camera_metadata_t*>(metadata.data());
2092 size_t expectedSize = metadata.size();
2093 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2094 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2095 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2096 mPhysicalCameraCharacteristics[id] = buffer;
2097 } else {
2098 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2099 status = Status::INTERNAL_ERROR;
2100 }
2101 }
2102 });
2103
2104 if (!ret.isOk()) {
2105 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002106 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002107 return;
2108 }
2109 if (status != Status::OK) {
2110 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
2111 __FUNCTION__, id.c_str(), mId.c_str(),
2112 CameraProviderManager::statusToString(status), status);
2113 return;
2114 }
2115 }
2116 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002117
2118 if (!kEnableLazyHal) {
2119 // Save HAL reference indefinitely
2120 mSavedInterface = interface;
2121 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002122}
2123
2124CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
2125
2126status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002127 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002128}
2129
2130status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
2131 hardware::CameraInfo *info) const {
2132 if (info == nullptr) return BAD_VALUE;
2133
2134 camera_metadata_ro_entry facing =
2135 mCameraCharacteristics.find(ANDROID_LENS_FACING);
2136 if (facing.count == 1) {
2137 switch (facing.data.u8[0]) {
2138 case ANDROID_LENS_FACING_BACK:
2139 info->facing = hardware::CAMERA_FACING_BACK;
2140 break;
2141 case ANDROID_LENS_FACING_EXTERNAL:
2142 // Map external to front for legacy API
2143 case ANDROID_LENS_FACING_FRONT:
2144 info->facing = hardware::CAMERA_FACING_FRONT;
2145 break;
2146 }
2147 } else {
2148 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
2149 return NAME_NOT_FOUND;
2150 }
2151
2152 camera_metadata_ro_entry orientation =
2153 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
2154 if (orientation.count == 1) {
2155 info->orientation = orientation.data.i32[0];
2156 } else {
2157 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
2158 return NAME_NOT_FOUND;
2159 }
2160
2161 return OK;
2162}
Emilian Peevf53f66e2017-04-11 14:29:43 +01002163bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07002164 // Do not advertise NIR cameras to API1 camera app.
2165 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
2166 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
2167 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
2168 return false;
2169 }
2170
Emilian Peevf53f66e2017-04-11 14:29:43 +01002171 bool isBackwardCompatible = false;
2172 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
2173 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
2174 for (size_t i = 0; i < caps.count; i++) {
2175 if (caps.data.u8[i] ==
2176 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2177 isBackwardCompatible = true;
2178 break;
2179 }
2180 }
2181
2182 return isBackwardCompatible;
2183}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002184
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002185status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002186 native_handle_t* handle = native_handle_create(1,0);
2187 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002188 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
2189 if (interface == nullptr) {
2190 return DEAD_OBJECT;
2191 }
2192 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002193 native_handle_delete(handle);
2194 if (!ret.isOk()) {
2195 return INVALID_OPERATION;
2196 }
2197 return OK;
2198}
2199
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002200status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
2201 CameraMetadata *characteristics) const {
2202 if (characteristics == nullptr) return BAD_VALUE;
2203
2204 *characteristics = mCameraCharacteristics;
2205 return OK;
2206}
2207
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002208status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
2209 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
2210 if (characteristics == nullptr) return BAD_VALUE;
2211 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
2212 mPhysicalCameraCharacteristics.end()) {
2213 return NAME_NOT_FOUND;
2214 }
2215
2216 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
2217 return OK;
2218}
2219
Emilian Peev35ae8262018-11-08 13:11:32 +00002220status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
2221 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002222 bool *status /*out*/) {
2223
2224 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2225 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2226 if (interface == nullptr) {
2227 return DEAD_OBJECT;
2228 }
2229 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Emilian Peev35ae8262018-11-08 13:11:32 +00002230 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
2231 if (interface_3_5 == nullptr) {
2232 return INVALID_OPERATION;
2233 }
2234
2235 status_t res;
2236 Status callStatus;
2237 auto ret = interface_3_5->isStreamCombinationSupported(configuration,
2238 [&callStatus, &status] (Status s, bool combStatus) {
2239 callStatus = s;
2240 *status = combStatus;
2241 });
2242 if (ret.isOk()) {
2243 switch (callStatus) {
2244 case Status::OK:
2245 // Expected case, do nothing.
2246 res = OK;
2247 break;
2248 case Status::METHOD_NOT_SUPPORTED:
2249 res = INVALID_OPERATION;
2250 break;
2251 default:
2252 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
2253 res = UNKNOWN_ERROR;
2254 }
2255 } else {
2256 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2257 res = UNKNOWN_ERROR;
2258 }
2259
2260 return res;
2261}
2262
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002263status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
2264 std::string *type, uint32_t *id) {
2265 // Format must be "<type>/<id>"
2266#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
2267 "Should match '<type>/<id>' - "
2268
2269 if (!type || !id) return INVALID_OPERATION;
2270
2271 std::string::size_type slashIdx = name.find('/');
2272 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
2273 ALOGE(ERROR_MSG_PREFIX
2274 "does not have / separator between type and id",
2275 __FUNCTION__, name.c_str());
2276 return BAD_VALUE;
2277 }
2278
2279 std::string typeVal = name.substr(0, slashIdx);
2280
2281 char *endPtr;
2282 errno = 0;
2283 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
2284 if (errno != 0) {
2285 ALOGE(ERROR_MSG_PREFIX
2286 "cannot parse provider id as an integer: %s (%d)",
2287 __FUNCTION__, name.c_str(), strerror(errno), errno);
2288 return BAD_VALUE;
2289 }
2290 if (endPtr != name.c_str() + name.size()) {
2291 ALOGE(ERROR_MSG_PREFIX
2292 "provider id has unexpected length",
2293 __FUNCTION__, name.c_str());
2294 return BAD_VALUE;
2295 }
2296 if (idVal < 0) {
2297 ALOGE(ERROR_MSG_PREFIX
2298 "id is negative: %ld",
2299 __FUNCTION__, name.c_str(), idVal);
2300 return BAD_VALUE;
2301 }
2302
2303#undef ERROR_MSG_PREFIX
2304
2305 *type = typeVal;
2306 *id = static_cast<uint32_t>(idVal);
2307
2308 return OK;
2309}
2310
Emilian Peev71c73a22017-03-21 16:35:51 +00002311metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
2312 const std::string &name) {
2313 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
2314 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
2315 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
2316 ret = 0;
2317 }
2318
2319 return ret;
2320}
2321
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002322status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
2323 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
2324
2325 // Format must be "device@<major>.<minor>/<type>/<id>"
2326
2327#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
2328 "Should match 'device@<major>.<minor>/<type>/<id>' - "
2329
2330 if (!major || !minor || !type || !id) return INVALID_OPERATION;
2331
2332 // Verify starting prefix
2333 const char expectedPrefix[] = "device@";
2334
2335 if (name.find(expectedPrefix) != 0) {
2336 ALOGE(ERROR_MSG_PREFIX
2337 "does not start with '%s'",
2338 __FUNCTION__, name.c_str(), expectedPrefix);
2339 return BAD_VALUE;
2340 }
2341
2342 // Extract major/minor versions
2343 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
2344 std::string::size_type dotIdx = name.find('.', atIdx);
2345 if (dotIdx == std::string::npos) {
2346 ALOGE(ERROR_MSG_PREFIX
2347 "does not have @<major>. version section",
2348 __FUNCTION__, name.c_str());
2349 return BAD_VALUE;
2350 }
2351 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
2352 if (typeSlashIdx == std::string::npos) {
2353 ALOGE(ERROR_MSG_PREFIX
2354 "does not have .<minor>/ version section",
2355 __FUNCTION__, name.c_str());
2356 return BAD_VALUE;
2357 }
2358
2359 char *endPtr;
2360 errno = 0;
2361 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
2362 if (errno != 0) {
2363 ALOGE(ERROR_MSG_PREFIX
2364 "cannot parse major version: %s (%d)",
2365 __FUNCTION__, name.c_str(), strerror(errno), errno);
2366 return BAD_VALUE;
2367 }
2368 if (endPtr != name.c_str() + dotIdx) {
2369 ALOGE(ERROR_MSG_PREFIX
2370 "major version has unexpected length",
2371 __FUNCTION__, name.c_str());
2372 return BAD_VALUE;
2373 }
2374 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
2375 if (errno != 0) {
2376 ALOGE(ERROR_MSG_PREFIX
2377 "cannot parse minor version: %s (%d)",
2378 __FUNCTION__, name.c_str(), strerror(errno), errno);
2379 return BAD_VALUE;
2380 }
2381 if (endPtr != name.c_str() + typeSlashIdx) {
2382 ALOGE(ERROR_MSG_PREFIX
2383 "minor version has unexpected length",
2384 __FUNCTION__, name.c_str());
2385 return BAD_VALUE;
2386 }
2387 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
2388 ALOGE(ERROR_MSG_PREFIX
2389 "major/minor version is out of range of uint16_t: %ld.%ld",
2390 __FUNCTION__, name.c_str(), majorVal, minorVal);
2391 return BAD_VALUE;
2392 }
2393
2394 // Extract type and id
2395
2396 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
2397 if (instanceSlashIdx == std::string::npos) {
2398 ALOGE(ERROR_MSG_PREFIX
2399 "does not have /<type>/ component",
2400 __FUNCTION__, name.c_str());
2401 return BAD_VALUE;
2402 }
2403 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
2404
2405 if (instanceSlashIdx == name.size() - 1) {
2406 ALOGE(ERROR_MSG_PREFIX
2407 "does not have an /<id> component",
2408 __FUNCTION__, name.c_str());
2409 return BAD_VALUE;
2410 }
2411 std::string idVal = name.substr(instanceSlashIdx + 1);
2412
2413#undef ERROR_MSG_PREFIX
2414
2415 *major = static_cast<uint16_t>(majorVal);
2416 *minor = static_cast<uint16_t>(minorVal);
2417 *type = typeVal;
2418 *id = idVal;
2419
2420 return OK;
2421}
2422
2423
2424
2425CameraProviderManager::ProviderInfo::~ProviderInfo() {
2426 // Destruction of ProviderInfo is only supposed to happen when the respective
2427 // CameraProvider interface dies, so do not unregister callbacks.
2428
2429}
2430
2431status_t CameraProviderManager::mapToStatusT(const Status& s) {
2432 switch(s) {
2433 case Status::OK:
2434 return OK;
2435 case Status::ILLEGAL_ARGUMENT:
2436 return BAD_VALUE;
2437 case Status::CAMERA_IN_USE:
2438 return -EBUSY;
2439 case Status::MAX_CAMERAS_IN_USE:
2440 return -EUSERS;
2441 case Status::METHOD_NOT_SUPPORTED:
2442 return UNKNOWN_TRANSACTION;
2443 case Status::OPERATION_NOT_SUPPORTED:
2444 return INVALID_OPERATION;
2445 case Status::CAMERA_DISCONNECTED:
2446 return DEAD_OBJECT;
2447 case Status::INTERNAL_ERROR:
2448 return INVALID_OPERATION;
2449 }
2450 ALOGW("Unexpected HAL status code %d", s);
2451 return INVALID_OPERATION;
2452}
2453
2454const char* CameraProviderManager::statusToString(const Status& s) {
2455 switch(s) {
2456 case Status::OK:
2457 return "OK";
2458 case Status::ILLEGAL_ARGUMENT:
2459 return "ILLEGAL_ARGUMENT";
2460 case Status::CAMERA_IN_USE:
2461 return "CAMERA_IN_USE";
2462 case Status::MAX_CAMERAS_IN_USE:
2463 return "MAX_CAMERAS_IN_USE";
2464 case Status::METHOD_NOT_SUPPORTED:
2465 return "METHOD_NOT_SUPPORTED";
2466 case Status::OPERATION_NOT_SUPPORTED:
2467 return "OPERATION_NOT_SUPPORTED";
2468 case Status::CAMERA_DISCONNECTED:
2469 return "CAMERA_DISCONNECTED";
2470 case Status::INTERNAL_ERROR:
2471 return "INTERNAL_ERROR";
2472 }
2473 ALOGW("Unexpected HAL status code %d", s);
2474 return "UNKNOWN_ERROR";
2475}
2476
2477const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
2478 switch(s) {
2479 case CameraDeviceStatus::NOT_PRESENT:
2480 return "NOT_PRESENT";
2481 case CameraDeviceStatus::PRESENT:
2482 return "PRESENT";
2483 case CameraDeviceStatus::ENUMERATING:
2484 return "ENUMERATING";
2485 }
2486 ALOGW("Unexpected HAL device status code %d", s);
2487 return "UNKNOWN_STATUS";
2488}
2489
2490const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
2491 switch(s) {
2492 case TorchModeStatus::NOT_AVAILABLE:
2493 return "NOT_AVAILABLE";
2494 case TorchModeStatus::AVAILABLE_OFF:
2495 return "AVAILABLE_OFF";
2496 case TorchModeStatus::AVAILABLE_ON:
2497 return "AVAILABLE_ON";
2498 }
2499 ALOGW("Unexpected HAL torch mode status code %d", s);
2500 return "UNKNOWN_STATUS";
2501}
2502
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002503
2504status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002505 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002506 /*out*/
2507 sp<VendorTagDescriptor>& descriptor) {
2508
2509 int tagCount = 0;
2510
2511 for (size_t s = 0; s < vts.size(); s++) {
2512 tagCount += vts[s].tags.size();
2513 }
2514
2515 if (tagCount < 0 || tagCount > INT32_MAX) {
2516 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
2517 return BAD_VALUE;
2518 }
2519
2520 Vector<uint32_t> tagArray;
2521 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
2522 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
2523
2524
2525 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
2526 desc->mTagCount = tagCount;
2527
2528 SortedVector<String8> sections;
2529 KeyedVector<uint32_t, String8> tagToSectionMap;
2530
2531 int idx = 0;
2532 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002533 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002534 const char *sectionName = section.sectionName.c_str();
2535 if (sectionName == NULL) {
2536 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
2537 return BAD_VALUE;
2538 }
2539 String8 sectionString(sectionName);
2540 sections.add(sectionString);
2541
2542 for (size_t j = 0; j < section.tags.size(); j++) {
2543 uint32_t tag = section.tags[j].tagId;
2544 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
2545 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
2546 return BAD_VALUE;
2547 }
2548
2549 tagArray.editItemAt(idx++) = section.tags[j].tagId;
2550
2551 const char *tagName = section.tags[j].tagName.c_str();
2552 if (tagName == NULL) {
2553 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
2554 return BAD_VALUE;
2555 }
2556 desc->mTagToNameMap.add(tag, String8(tagName));
2557 tagToSectionMap.add(tag, sectionString);
2558
2559 int tagType = (int) section.tags[j].tagType;
2560 if (tagType < 0 || tagType >= NUM_TYPES) {
2561 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
2562 return BAD_VALUE;
2563 }
2564 desc->mTagToTypeMap.add(tag, tagType);
2565 }
2566 }
2567
2568 desc->mSections = sections;
2569
2570 for (size_t i = 0; i < tagArray.size(); ++i) {
2571 uint32_t tag = tagArray[i];
2572 String8 sectionString = tagToSectionMap.valueFor(tag);
2573
2574 // Set up tag to section index map
2575 ssize_t index = sections.indexOf(sectionString);
2576 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
2577 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
2578
2579 // Set up reverse mapping
2580 ssize_t reverseIndex = -1;
2581 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
2582 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
2583 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
2584 }
2585 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
2586 }
2587
George Burgess IVa0b84962017-08-29 17:46:19 -07002588 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002589 return OK;
2590}
2591
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002592status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
2593 CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002594 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
2595 if (deviceInfo != nullptr) {
2596 return deviceInfo->getCameraCharacteristics(characteristics);
2597 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002598
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002599 // Find hidden physical camera characteristics
2600 for (auto& provider : mProviders) {
2601 for (auto& deviceInfo : provider->mDevices) {
2602 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
2603 if (res != NAME_NOT_FOUND) return res;
2604 }
2605 }
2606
2607 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002608}
2609
2610void CameraProviderManager::filterLogicalCameraIdsLocked(
2611 std::vector<std::string>& deviceIds) const
2612{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002613 // Map between camera facing and camera IDs related to logical camera.
2614 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002615
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002616 // Collect all logical and its underlying physical camera IDs for each
2617 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002618 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002619 auto deviceInfo = findDeviceInfoLocked(deviceId);
2620 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002621
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002622 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002623 continue;
2624 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002625
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002626 // combo contains the ids of a logical camera and its physical cameras
2627 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
2628 combo.push_back(deviceId);
2629
2630 hardware::CameraInfo info;
2631 status_t res = deviceInfo->getCameraInfo(&info);
2632 if (res != OK) {
2633 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
2634 continue;
2635 }
2636 idCombos[info.facing].insert(combo.begin(), combo.end());
2637 }
2638
2639 // Only expose one camera ID per facing for all logical and underlying
2640 // physical camera IDs.
2641 for (auto& r : idCombos) {
2642 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002643 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002644 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
2645 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002646 continue;
2647 }
2648
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002649 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002650 break;
2651 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002652 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
2653 [&removedIds](const std::string& s) {
2654 return removedIds.find(s) != removedIds.end();}),
2655 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002656 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002657}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002658
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002659} // namespace android