blob: 974026cbc998bcdc1601638f406e3d536f300a26 [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"
43
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080044namespace android {
45
46using namespace ::android::hardware::camera;
47using namespace ::android::hardware::camera::common::V1_0;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070048using std::literals::chrono_literals::operator""s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080049
50namespace {
Peter Kalauskasa29c1352018-10-10 12:05:42 -070051const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080052} // anonymous namespace
53
Emilian Peev538c90e2018-12-17 18:03:19 +000054const float CameraProviderManager::kDepthARTolerance = .1f;
55
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080056CameraProviderManager::HardwareServiceInteractionProxy
57CameraProviderManager::sHardwareServiceInteractionProxy{};
58
59CameraProviderManager::~CameraProviderManager() {
60}
61
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070062hardware::hidl_vec<hardware::hidl_string>
63CameraProviderManager::HardwareServiceInteractionProxy::listServices() {
64 hardware::hidl_vec<hardware::hidl_string> ret;
65 auto manager = hardware::defaultServiceManager1_2();
66 if (manager != nullptr) {
67 manager->listManifestByInterface(provider::V2_4::ICameraProvider::descriptor,
68 [&ret](const hardware::hidl_vec<hardware::hidl_string> &registered) {
69 ret = registered;
70 });
71 }
72 return ret;
73}
74
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080075status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
76 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080077 std::lock_guard<std::mutex> lock(mInterfaceMutex);
78 if (proxy == nullptr) {
79 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
80 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080081 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080082 mListener = listener;
83 mServiceProxy = proxy;
Eino-Ville Talvala63f36112018-12-06 14:57:03 -080084 mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
85 provider::V2_5::DeviceState::NORMAL);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080086
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080087 // Registering will trigger notifications for all already-known providers
88 bool success = mServiceProxy->registerForNotifications(
89 /* instance name, empty means no filter */ "",
90 this);
91 if (!success) {
92 ALOGE("%s: Unable to register with hardware service manager for notifications "
93 "about camera providers", __FUNCTION__);
94 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080095 }
Emilian Peev5d7e5152017-02-22 15:37:48 +000096
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -070097
98 for (const auto& instance : mServiceProxy->listServices()) {
99 this->addProviderLocked(instance);
100 }
Eino-Ville Talvala65665362017-02-24 13:07:56 -0800101
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700102 IPCThreadState::self()->flushCommands();
103
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800104 return OK;
105}
106
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700107std::pair<int, int> CameraProviderManager::getCameraCount() const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800108 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700109 int systemCameraCount = 0;
110 int publicCameraCount = 0;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800111 for (auto& provider : mProviders) {
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700112 for (auto &id : provider->mUniqueCameraIds) {
113 switch(getSystemCameraKindLocked(id)) {
114 case SystemCameraKind::PUBLIC:
115 publicCameraCount++;
116 break;
117 case SystemCameraKind::SYSTEM_ONLY_CAMERA:
118 systemCameraCount++;
119 break;
120 default:
121 break;
122 }
123 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800124 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700125 return std::make_pair(systemCameraCount, publicCameraCount);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800126}
127
128std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
129 std::lock_guard<std::mutex> lock(mInterfaceMutex);
130 std::vector<std::string> deviceIds;
131 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700132 for (auto& id : provider->mUniqueCameraIds) {
133 deviceIds.push_back(id);
134 }
135 }
136 return deviceIds;
137}
138
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700139void CameraProviderManager::collectDeviceIdsLocked(const std::vector<std::string> deviceIds,
140 std::vector<std::string>& publicDeviceIds,
141 std::vector<std::string>& systemDeviceIds) const {
142 for (auto &deviceId : deviceIds) {
143 if (getSystemCameraKindLocked(deviceId) == SystemCameraKind::SYSTEM_ONLY_CAMERA) {
144 systemDeviceIds.push_back(deviceId);
145 } else {
146 publicDeviceIds.push_back(deviceId);
147 }
148 }
149}
150
Emilian Peevf53f66e2017-04-11 14:29:43 +0100151std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700152 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700153 std::vector<std::string> publicDeviceIds;
154 std::vector<std::string> systemDeviceIds;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700155 std::vector<std::string> deviceIds;
156 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700157 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700158 // Secure cameras should not be exposed through camera 1 api
159 providerDeviceIds.erase(std::remove_if(providerDeviceIds.begin(), providerDeviceIds.end(),
160 [this](const std::string& s) {
161 bool rem = this->getSystemCameraKindLocked(s) ==
162 SystemCameraKind::HIDDEN_SECURE_CAMERA;
163 return rem;}), providerDeviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700164 // API1 app doesn't handle logical and physical camera devices well. So
Shuzhen Wang38e119b2018-10-01 16:03:53 -0700165 // for each camera facing, only take the first id advertised by HAL in
166 // all [logical, physical1, physical2, ...] id combos, and filter out the rest.
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700167 filterLogicalCameraIdsLocked(providerDeviceIds);
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700168 collectDeviceIdsLocked(providerDeviceIds, publicDeviceIds, systemDeviceIds);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800169 }
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700170 auto sortFunc =
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800171 [](const std::string& a, const std::string& b) -> bool {
172 uint32_t aUint = 0, bUint = 0;
173 bool aIsUint = base::ParseUint(a, &aUint);
174 bool bIsUint = base::ParseUint(b, &bUint);
175
176 // Uint device IDs first
177 if (aIsUint && bIsUint) {
178 return aUint < bUint;
179 } else if (aIsUint) {
180 return true;
181 } else if (bIsUint) {
182 return false;
183 }
184 // Simple string compare if both id are not uint
185 return a < b;
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700186 };
187 // We put device ids for system cameras at the end since they will be pared
188 // off for processes not having system camera permissions.
189 std::sort(publicDeviceIds.begin(), publicDeviceIds.end(), sortFunc);
190 std::sort(systemDeviceIds.begin(), systemDeviceIds.end(), sortFunc);
191 deviceIds.insert(deviceIds.end(), publicDeviceIds.begin(), publicDeviceIds.end());
192 deviceIds.insert(deviceIds.end(), systemDeviceIds.begin(), systemDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800193 return deviceIds;
194}
195
196bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
197 std::lock_guard<std::mutex> lock(mInterfaceMutex);
198 return isValidDeviceLocked(id, majorVersion);
199}
200
201bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
202 for (auto& provider : mProviders) {
203 for (auto& deviceInfo : provider->mDevices) {
204 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
205 return true;
206 }
207 }
208 }
209 return false;
210}
211
212bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
213 std::lock_guard<std::mutex> lock(mInterfaceMutex);
214
215 auto deviceInfo = findDeviceInfoLocked(id);
216 if (deviceInfo == nullptr) return false;
217
218 return deviceInfo->hasFlashUnit();
219}
220
221status_t CameraProviderManager::getResourceCost(const std::string &id,
222 CameraResourceCost* cost) const {
223 std::lock_guard<std::mutex> lock(mInterfaceMutex);
224
225 auto deviceInfo = findDeviceInfoLocked(id);
226 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
227
228 *cost = deviceInfo->mResourceCost;
229 return OK;
230}
231
232status_t CameraProviderManager::getCameraInfo(const std::string &id,
233 hardware::CameraInfo* info) const {
234 std::lock_guard<std::mutex> lock(mInterfaceMutex);
235
236 auto deviceInfo = findDeviceInfoLocked(id);
237 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
238
239 return deviceInfo->getCameraInfo(info);
240}
241
Emilian Peev35ae8262018-11-08 13:11:32 +0000242status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
243 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
244 bool *status /*out*/) const {
245 std::lock_guard<std::mutex> lock(mInterfaceMutex);
246
247 auto deviceInfo = findDeviceInfoLocked(id);
248 if (deviceInfo == nullptr) {
249 return NAME_NOT_FOUND;
250 }
251
252 return deviceInfo->isSessionConfigurationSupported(configuration, status);
253}
254
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800255status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
256 CameraMetadata* characteristics) const {
257 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700258 return getCameraCharacteristicsLocked(id, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800259}
260
261status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
262 hardware::hidl_version *v) {
263 std::lock_guard<std::mutex> lock(mInterfaceMutex);
264
265 hardware::hidl_version maxVersion{0,0};
266 bool found = false;
267 for (auto& provider : mProviders) {
268 for (auto& deviceInfo : provider->mDevices) {
269 if (deviceInfo->mId == id) {
270 if (deviceInfo->mVersion > maxVersion) {
271 maxVersion = deviceInfo->mVersion;
272 found = true;
273 }
274 }
275 }
276 }
277 if (!found) {
278 return NAME_NOT_FOUND;
279 }
280 *v = maxVersion;
281 return OK;
282}
283
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700284bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700285 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700286 for (auto& provider : mProviders) {
287 auto deviceInfo = findDeviceInfoLocked(id);
288 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700289 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700290 }
291 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700292 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700293}
294
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800295status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
296 std::lock_guard<std::mutex> lock(mInterfaceMutex);
297
298 auto deviceInfo = findDeviceInfoLocked(id);
299 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
300
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700301 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
302 // that are currently in use.
303 const sp<provider::V2_4::ICameraProvider> interface =
304 deviceInfo->mParentProvider->startProviderInterface();
305 if (interface == nullptr) {
306 return DEAD_OBJECT;
307 }
308 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
309
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800310 return deviceInfo->setTorchMode(enabled);
311}
312
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800313status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000314 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
315
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800316 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800317 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800318 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000319
320 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
321
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800322 return OK;
323}
324
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800325status_t CameraProviderManager::notifyDeviceStateChange(
326 hardware::hidl_bitfield<provider::V2_5::DeviceState> newState) {
327 std::lock_guard<std::mutex> lock(mInterfaceMutex);
328 mDeviceState = newState;
329 status_t res = OK;
330 for (auto& provider : mProviders) {
331 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
332 __FUNCTION__, provider->mProviderName.c_str(), newState);
333 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
334 if (singleRes != OK) {
335 ALOGE("%s: Unable to notify provider %s about device state change",
336 __FUNCTION__,
337 provider->mProviderName.c_str());
338 res = singleRes;
339 // continue to do the rest of the providers instead of returning now
340 }
341 }
342 return res;
343}
344
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800345status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800346 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800347 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800348 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800349
350 std::lock_guard<std::mutex> lock(mInterfaceMutex);
351
352 auto deviceInfo = findDeviceInfoLocked(id,
353 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
354 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
355
356 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700357 const sp<provider::V2_4::ICameraProvider> provider =
358 deviceInfo->mParentProvider->startProviderInterface();
359 if (provider == nullptr) {
360 return DEAD_OBJECT;
361 }
362 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800363
364 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700365 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700366 auto interface = deviceInfo3->startDeviceInterface<
367 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
368 if (interface == nullptr) {
369 return DEAD_OBJECT;
370 }
371
372 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800373 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
374 status = s;
375 if (status == Status::OK) {
376 *session = cameraSession;
377 }
378 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700379 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700380 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700381 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
382 __FUNCTION__, id.c_str(), ret.description().c_str());
383 return DEAD_OBJECT;
384 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800385 return mapToStatusT(status);
386}
387
388status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800389 const sp<device::V1_0::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800390 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800391 sp<device::V1_0::ICameraDevice> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800392
393 std::lock_guard<std::mutex> lock(mInterfaceMutex);
394
395 auto deviceInfo = findDeviceInfoLocked(id,
396 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
397 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
398
399 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700400 const sp<provider::V2_4::ICameraProvider> provider =
401 deviceInfo->mParentProvider->startProviderInterface();
402 if (provider == nullptr) {
403 return DEAD_OBJECT;
404 }
405 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800406
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700407 auto interface = deviceInfo1->startDeviceInterface<
408 CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT>();
409 if (interface == nullptr) {
410 return DEAD_OBJECT;
411 }
412 hardware::Return<Status> status = interface->open(callback);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700413 if (!status.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700414 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700415 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
416 __FUNCTION__, id.c_str(), status.description().c_str());
417 return DEAD_OBJECT;
418 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800419 if (status == Status::OK) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700420 *session = interface;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800421 }
422 return mapToStatusT(status);
423}
424
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700425void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
426 sp<provider::V2_4::ICameraProvider> provider) {
427 if (!kEnableLazyHal) {
428 return;
429 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800430 ALOGV("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700431 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
432 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
433 if (usageType == DeviceMode::TORCH) {
434 primaryMap = &mTorchProviderByCameraId;
435 alternateMap = &mCameraProviderByCameraId;
436 } else {
437 primaryMap = &mCameraProviderByCameraId;
438 alternateMap = &mTorchProviderByCameraId;
439 }
440 auto id = cameraId.c_str();
441 (*primaryMap)[id] = provider;
442 auto search = alternateMap->find(id);
443 if (search != alternateMap->end()) {
444 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
445 "That should not be possible", __FUNCTION__, id);
446 }
447 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
448}
449
450void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
451 if (!kEnableLazyHal) {
452 return;
453 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800454 ALOGV("Removing camera device %s", cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700455 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
456 if (usageType == DeviceMode::TORCH) {
457 providerMap = &mTorchProviderByCameraId;
458 } else {
459 providerMap = &mCameraProviderByCameraId;
460 }
461 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
462 auto search = providerMap->find(cameraId.c_str());
463 if (search != providerMap->end()) {
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800464 // Drop the reference to this ICameraProvider. This is safe to do immediately (without an
465 // added delay) because hwservicemanager guarantees to hold the reference for at least five
466 // more seconds. We depend on this behavior so that if the provider is unreferenced and
467 // then referenced again quickly, we do not let the HAL exit and then need to immediately
468 // restart it. An example when this could happen is switching from a front-facing to a
469 // rear-facing camera. If the HAL were to exit during the camera switch, the camera could
470 // appear janky to the user.
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700471 providerMap->erase(cameraId.c_str());
Peter Kalauskas26af1a52019-01-25 06:57:01 -0800472 IPCThreadState::self()->flushCommands();
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700473 } else {
474 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
475 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
476 cameraId.c_str());
477 }
478}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800479
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800480hardware::Return<void> CameraProviderManager::onRegistration(
481 const hardware::hidl_string& /*fqName*/,
482 const hardware::hidl_string& name,
483 bool /*preexisting*/) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700484 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100485 {
486 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800487
Emilian Peevaee727d2017-05-04 16:35:48 +0100488 addProviderLocked(name);
489 }
490
491 sp<StatusListener> listener = getStatusListener();
492 if (nullptr != listener.get()) {
493 listener->onNewProviderRegistered();
494 }
495
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700496 IPCThreadState::self()->flushCommands();
497
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800498 return hardware::Return<void>();
499}
500
501status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
502 std::lock_guard<std::mutex> lock(mInterfaceMutex);
503
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800504 for (auto& provider : mProviders) {
505 provider->dump(fd, args);
506 }
507 return OK;
508}
509
510CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800511 const std::string& id,
512 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800513 for (auto& provider : mProviders) {
514 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800515 if (deviceInfo->mId == id &&
516 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800517 return deviceInfo.get();
518 }
519 }
520 }
521 return nullptr;
522}
523
Emilian Peev71c73a22017-03-21 16:35:51 +0000524metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
525 const std::string& id, hardware::hidl_version minVersion,
526 hardware::hidl_version maxVersion) const {
527 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
528
529 std::lock_guard<std::mutex> lock(mInterfaceMutex);
530 for (auto& provider : mProviders) {
531 for (auto& deviceInfo : provider->mDevices) {
532 if (deviceInfo->mId == id &&
533 minVersion <= deviceInfo->mVersion &&
534 maxVersion >= deviceInfo->mVersion) {
535 return provider->mProviderTagid;
536 }
537 }
538 }
539
540 return ret;
541}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800542
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700543void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
544 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700545
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700546 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700547 for (size_t i = 0; i < entryCap.count; ++i) {
548 uint8_t capability = entryCap.data.u8[i];
549 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700550 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700551 break;
552 }
553 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700554 if (!mIsLogicalCamera) {
555 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700556 }
557
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700558 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
559 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700560 const uint8_t* ids = entryIds.data.u8;
561 size_t start = 0;
562 for (size_t i = 0; i < entryIds.count; ++i) {
563 if (ids[i] == '\0') {
564 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700565 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700566 }
567 start = i+1;
568 }
569 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700570}
571
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700572SystemCameraKind CameraProviderManager::ProviderInfo::DeviceInfo3::getSystemCameraKind() {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800573 camera_metadata_entry_t entryCap;
574 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700575 if (entryCap.count == 1 &&
576 entryCap.data.u8[0] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA) {
577 return SystemCameraKind::HIDDEN_SECURE_CAMERA;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800578 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700579
580 // Go through the capabilities and check if it has
581 // ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA
582 for (size_t i = 0; i < entryCap.count; ++i) {
583 uint8_t capability = entryCap.data.u8[i];
584 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA) {
585 return SystemCameraKind::SYSTEM_ONLY_CAMERA;
586 }
587 }
588 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800589}
590
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000591void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
592 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
593 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
594 if (sizes == nullptr) {
595 return;
596 }
597
598 auto scalerDims = ch.find(tag);
599 if (scalerDims.count > 0) {
600 // Scaler entry contains 4 elements (format, width, height, type)
601 for (size_t i = 0; i < scalerDims.count; i += 4) {
602 if ((scalerDims.data.i32[i] == format) &&
603 (scalerDims.data.i32[i+3] ==
604 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
605 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
606 scalerDims.data.i32[i+2]));
607 }
608 }
609 }
610}
611
612void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
613 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
614 const std::vector<std::tuple<size_t, size_t>>& sizes,
615 std::vector<int64_t> *durations/*out*/) {
616 if (durations == nullptr) {
617 return;
618 }
619
620 auto availableDurations = ch.find(tag);
621 if (availableDurations.count > 0) {
622 // Duration entry contains 4 elements (format, width, height, duration)
623 for (size_t i = 0; i < availableDurations.count; i += 4) {
624 for (const auto& size : sizes) {
625 int64_t width = std::get<0>(size);
626 int64_t height = std::get<1>(size);
627 if ((availableDurations.data.i64[i] == format) &&
628 (availableDurations.data.i64[i+1] == width) &&
629 (availableDurations.data.i64[i+2] == height)) {
630 durations->push_back(availableDurations.data.i64[i+3]);
631 }
632 }
633 }
634 }
635}
636void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
637 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
638 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
639 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
640 return;
641 }
642
643 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
644 // Processing time on camera service side can vary greatly depending on multiple
645 // variables which are not under our control. Make a guesstimate by taking the maximum
646 // corresponding duration value from depth and blob.
647 auto depthDuration = depthDurations.begin();
648 auto blobDuration = blobDurations.begin();
649 dynamicDepthDurations->reserve(depthDurations.size());
650 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
651 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
652 depthDuration++; blobDuration++;
653 }
654}
655
656void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
657 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
658 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
659 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
660 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
661 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
662 return;
663 }
664
665 // The dynamic depth spec. does not mention how close the AR ratio should be.
666 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000667 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000668
669 for (const auto& blobSize : blobSizes) {
670 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
671 static_cast<float>(std::get<1>(blobSize));
672 bool found = false;
673 for (const auto& depthSize : depthSizes) {
674 if (depthSize == blobSize) {
675 internalDepthSizes->push_back(depthSize);
676 found = true;
677 break;
678 } else {
679 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
680 static_cast<float>(std::get<1>(depthSize));
681 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
682 internalDepthSizes->push_back(depthSize);
683 found = true;
684 break;
685 }
686 }
687 }
688
689 if (found) {
690 dynamicDepthSizes->push_back(blobSize);
691 }
692 }
693}
694
Emilian Peevcbf174b2019-01-25 14:38:59 -0800695bool CameraProviderManager::ProviderInfo::DeviceInfo3::isDepthPhotoLibraryPresent() {
696 static bool libraryPresent = false;
697 static bool initialized = false;
698 if (initialized) {
699 return libraryPresent;
700 } else {
701 initialized = true;
702 }
703
704 void* depthLibHandle = dlopen(camera3::kDepthPhotoLibrary, RTLD_NOW | RTLD_LOCAL);
705 if (depthLibHandle == nullptr) {
706 return false;
707 }
708
709 auto processFunc = dlsym(depthLibHandle, camera3::kDepthPhotoProcessFunction);
710 if (processFunc != nullptr) {
711 libraryPresent = true;
712 } else {
713 libraryPresent = false;
714 }
715 dlclose(depthLibHandle);
716
717 return libraryPresent;
718}
719
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000720status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags() {
721 uint32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
722 uint32_t depthSizesTag = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS;
723 auto& c = mCameraCharacteristics;
724 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
725 supportedDynamicDepthSizes, internalDepthSizes;
726 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
727 if (chTags.count == 0) {
728 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
729 return BAD_VALUE;
730 }
731
732 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
733 depthExclTag) != (chTags.data.i32 + chTags.count);
734 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
Emilian Peeva1185162019-01-30 16:41:43 -0800735 depthSizesTag) != (chTags.data.i32 + chTags.count);
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000736 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
737 // No depth support, nothing more to do.
738 return OK;
739 }
740
741 auto depthExclusiveEntry = c.find(depthExclTag);
742 if (depthExclusiveEntry.count > 0) {
743 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
744 // Depth support is exclusive, nothing more to do.
745 return OK;
746 }
747 } else {
748 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
749 return BAD_VALUE;
750 }
751
752 getSupportedSizes(c, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, HAL_PIXEL_FORMAT_BLOB,
753 &supportedBlobSizes);
754 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
755 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
756 // Nothing to do in this case.
757 return OK;
758 }
759
760 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
761 &supportedDynamicDepthSizes, &internalDepthSizes);
762 if (supportedDynamicDepthSizes.empty()) {
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000763 // Nothing more to do.
764 return OK;
765 }
766
Emilian Peevcbf174b2019-01-25 14:38:59 -0800767 if(!isDepthPhotoLibraryPresent()) {
768 // Depth photo processing library is not present, nothing more to do.
769 return OK;
770 }
771
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000772 std::vector<int32_t> dynamicDepthEntries;
773 for (const auto& it : supportedDynamicDepthSizes) {
774 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
775 static_cast<int32_t> (std::get<1>(it)),
776 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
777 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
778 }
779
780 std::vector<int64_t> depthMinDurations, depthStallDurations;
781 std::vector<int64_t> blobMinDurations, blobStallDurations;
782 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
783
784 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,
785 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthMinDurations);
786 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
787 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobMinDurations);
788 if (blobMinDurations.empty() || depthMinDurations.empty() ||
789 (depthMinDurations.size() != blobMinDurations.size())) {
790 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
791 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
792 return BAD_VALUE;
793 }
794
795 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS,
796 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthStallDurations);
797 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
798 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobStallDurations);
799 if (blobStallDurations.empty() || depthStallDurations.empty() ||
800 (depthStallDurations.size() != blobStallDurations.size())) {
801 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
802 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
803 return BAD_VALUE;
804 }
805
806 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
807 &dynamicDepthMinDurations);
808 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
809 &dynamicDepthStallDurations);
810 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
811 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
812 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
813 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
814 return BAD_VALUE;
815 }
816
817 std::vector<int64_t> dynamicDepthMinDurationEntries;
818 auto itDuration = dynamicDepthMinDurations.begin();
819 auto itSize = supportedDynamicDepthSizes.begin();
820 while (itDuration != dynamicDepthMinDurations.end()) {
821 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
822 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
823 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
824 entry + 4);
825 itDuration++; itSize++;
826 }
827
828 std::vector<int64_t> dynamicDepthStallDurationEntries;
829 itDuration = dynamicDepthStallDurations.begin();
830 itSize = supportedDynamicDepthSizes.begin();
831 while (itDuration != dynamicDepthStallDurations.end()) {
832 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
833 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
834 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
835 entry + 4);
836 itDuration++; itSize++;
837 }
838
839 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
840 dynamicDepthEntries.data(), dynamicDepthEntries.size());
841 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,
842 dynamicDepthMinDurationEntries.data(), dynamicDepthMinDurationEntries.size());
843 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,
844 dynamicDepthStallDurationEntries.data(), dynamicDepthStallDurationEntries.size());
845
846 std::vector<int32_t> supportedChTags;
847 supportedChTags.reserve(chTags.count + 3);
848 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
849 chTags.data.i32 + chTags.count);
850 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
851 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS);
852 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS);
853 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
854 supportedChTags.size());
855
856 return OK;
857}
858
Shuzhen Wang268a1362018-10-16 16:32:59 -0700859status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
860 status_t res = OK;
861 auto& c = mCameraCharacteristics;
862
863 // Override static metadata for MONOCHROME camera with older device version
864 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
865 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
866 for (size_t i = 0; i < cap.count; i++) {
867 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
868 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
869 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
870 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
871 if (res != OK) {
872 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
873 __FUNCTION__, strerror(-res), res);
874 return res;
875 }
876
877 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
878 const std::vector<uint32_t> sKeys = {
879 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
880 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
881 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
882 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
883 ANDROID_SENSOR_COLOR_TRANSFORM1,
884 ANDROID_SENSOR_COLOR_TRANSFORM2,
885 ANDROID_SENSOR_FORWARD_MATRIX1,
886 ANDROID_SENSOR_FORWARD_MATRIX2,
887 };
888 res = removeAvailableKeys(c, sKeys,
889 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
890 if (res != OK) {
891 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
892 __FUNCTION__, strerror(-res), res);
893 return res;
894 }
895
896 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
897 const std::vector<uint32_t> reqKeys = {
898 ANDROID_COLOR_CORRECTION_MODE,
899 ANDROID_COLOR_CORRECTION_TRANSFORM,
900 ANDROID_COLOR_CORRECTION_GAINS,
901 };
902 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
903 if (res != OK) {
904 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
905 __FUNCTION__, strerror(-res), res);
906 return res;
907 }
908
909 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
910 const std::vector<uint32_t> resKeys = {
911 ANDROID_SENSOR_GREEN_SPLIT,
912 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
913 ANDROID_COLOR_CORRECTION_MODE,
914 ANDROID_COLOR_CORRECTION_TRANSFORM,
915 ANDROID_COLOR_CORRECTION_GAINS,
916 };
917 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
918 if (res != OK) {
919 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
920 __FUNCTION__, strerror(-res), res);
921 return res;
922 }
923
924 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
925 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
926 for (size_t j = 1; j < blEntry.count; j++) {
927 blEntry.data.i32[j] = blEntry.data.i32[0];
928 }
929 }
930 }
931 }
932 return res;
933}
934
935status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
936 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
937 status_t res = OK;
938
939 camera_metadata_entry keysEntry = c.find(keyTag);
940 if (keysEntry.count == 0) {
941 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
942 return res;
943 }
944 std::vector<int32_t> vKeys;
945 vKeys.reserve(keysEntry.count);
946 for (size_t i = 0; i < keysEntry.count; i++) {
947 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
948 vKeys.push_back(keysEntry.data.i32[i]);
949 }
950 }
951 res = c.update(keyTag, vKeys.data(), vKeys.size());
952 return res;
953}
954
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -0800955status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fillHeicStreamCombinations(
956 std::vector<int32_t>* outputs,
957 std::vector<int64_t>* durations,
958 std::vector<int64_t>* stallDurations,
959 const camera_metadata_entry& halStreamConfigs,
960 const camera_metadata_entry& halStreamDurations) {
961 if (outputs == nullptr || durations == nullptr || stallDurations == nullptr) {
962 return BAD_VALUE;
963 }
964
965 static bool supportInMemoryTempFile =
966 camera3::HeicCompositeStream::isInMemoryTempFileSupported();
967 if (!supportInMemoryTempFile) {
968 ALOGI("%s: No HEIC support due to absence of in memory temp file support",
969 __FUNCTION__);
970 return OK;
971 }
972
973 for (size_t i = 0; i < halStreamConfigs.count; i += 4) {
974 int32_t format = halStreamConfigs.data.i32[i];
975 // Only IMPLEMENTATION_DEFINED and YUV_888 can be used to generate HEIC
976 // image.
977 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
978 format != HAL_PIXEL_FORMAT_YCBCR_420_888) {
979 continue;
980 }
981
982 bool sizeAvail = false;
983 for (size_t j = 0; j < outputs->size(); j+= 4) {
984 if ((*outputs)[j+1] == halStreamConfigs.data.i32[i+1] &&
985 (*outputs)[j+2] == halStreamConfigs.data.i32[i+2]) {
986 sizeAvail = true;
987 break;
988 }
989 }
990 if (sizeAvail) continue;
991
992 int64_t stall = 0;
993 bool useHeic, useGrid;
994 if (camera3::HeicCompositeStream::isSizeSupportedByHeifEncoder(
995 halStreamConfigs.data.i32[i+1], halStreamConfigs.data.i32[i+2],
996 &useHeic, &useGrid, &stall)) {
997 if (useGrid != (format == HAL_PIXEL_FORMAT_YCBCR_420_888)) {
998 continue;
999 }
1000
1001 // HEIC configuration
1002 int32_t config[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1003 halStreamConfigs.data.i32[i+2], 0 /*isInput*/};
1004 outputs->insert(outputs->end(), config, config + 4);
1005
1006 // HEIC minFrameDuration
1007 for (size_t j = 0; j < halStreamDurations.count; j += 4) {
1008 if (halStreamDurations.data.i64[j] == format &&
1009 halStreamDurations.data.i64[j+1] == halStreamConfigs.data.i32[i+1] &&
1010 halStreamDurations.data.i64[j+2] == halStreamConfigs.data.i32[i+2]) {
1011 int64_t duration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1012 halStreamConfigs.data.i32[i+2], halStreamDurations.data.i64[j+3]};
1013 durations->insert(durations->end(), duration, duration+4);
1014 break;
1015 }
1016 }
1017
1018 // HEIC stallDuration
1019 int64_t stallDuration[] = {HAL_PIXEL_FORMAT_BLOB, halStreamConfigs.data.i32[i+1],
1020 halStreamConfigs.data.i32[i+2], stall};
1021 stallDurations->insert(stallDurations->end(), stallDuration, stallDuration+4);
1022 }
1023 }
1024 return OK;
1025}
1026
1027status_t CameraProviderManager::ProviderInfo::DeviceInfo3::deriveHeicTags() {
1028 auto& c = mCameraCharacteristics;
1029
1030 camera_metadata_entry halHeicSupport = c.find(ANDROID_HEIC_INFO_SUPPORTED);
1031 if (halHeicSupport.count > 1) {
1032 ALOGE("%s: Invalid entry count %zu for ANDROID_HEIC_INFO_SUPPORTED",
1033 __FUNCTION__, halHeicSupport.count);
1034 return BAD_VALUE;
1035 } else if (halHeicSupport.count == 0 ||
1036 halHeicSupport.data.u8[0] == ANDROID_HEIC_INFO_SUPPORTED_FALSE) {
1037 // Camera HAL doesn't support mandatory stream combinations for HEIC.
1038 return OK;
1039 }
1040
1041 camera_metadata_entry maxJpegAppsSegments =
1042 c.find(ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT);
1043 if (maxJpegAppsSegments.count != 1 || maxJpegAppsSegments.data.u8[0] == 0 ||
1044 maxJpegAppsSegments.data.u8[0] > 16) {
1045 ALOGE("%s: ANDROID_HEIC_INFO_MAX_JPEG_APP_SEGMENTS_COUNT must be within [1, 16]",
1046 __FUNCTION__);
1047 return BAD_VALUE;
1048 }
1049
1050 // Populate HEIC output configurations and its related min frame duration
1051 // and stall duration.
1052 std::vector<int32_t> heicOutputs;
1053 std::vector<int64_t> heicDurations;
1054 std::vector<int64_t> heicStallDurations;
1055
1056 camera_metadata_entry halStreamConfigs =
1057 c.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
1058 camera_metadata_entry minFrameDurations =
1059 c.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
1060
1061 status_t res = fillHeicStreamCombinations(&heicOutputs, &heicDurations, &heicStallDurations,
1062 halStreamConfigs, minFrameDurations);
1063 if (res != OK) {
1064 ALOGE("%s: Failed to fill HEIC stream combinations: %s (%d)", __FUNCTION__,
1065 strerror(-res), res);
1066 return res;
1067 }
1068
1069 c.update(ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS,
1070 heicOutputs.data(), heicOutputs.size());
1071 c.update(ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS,
1072 heicDurations.data(), heicDurations.size());
1073 c.update(ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS,
1074 heicStallDurations.data(), heicStallDurations.size());
1075
1076 return OK;
1077}
1078
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001079bool CameraProviderManager::isLogicalCamera(const std::string& id,
1080 std::vector<std::string>* physicalCameraIds) {
1081 std::lock_guard<std::mutex> lock(mInterfaceMutex);
1082
1083 auto deviceInfo = findDeviceInfoLocked(id);
1084 if (deviceInfo == nullptr) return false;
1085
1086 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
1087 *physicalCameraIds = deviceInfo->mPhysicalIds;
1088 }
1089 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001090}
1091
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001092SystemCameraKind CameraProviderManager::getSystemCameraKind(const std::string& id) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001093 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001094 return getSystemCameraKindLocked(id);
1095}
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001096
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001097SystemCameraKind CameraProviderManager::getSystemCameraKindLocked(const std::string& id) const {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001098 auto deviceInfo = findDeviceInfoLocked(id);
1099 if (deviceInfo == nullptr) {
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001100 return SystemCameraKind::PUBLIC;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001101 }
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001102 return deviceInfo->mSystemCameraKind;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001103}
1104
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001105bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) {
1106 for (auto& provider : mProviders) {
1107 for (auto& deviceInfo : provider->mDevices) {
1108 if (deviceInfo->mId == cameraId) {
1109 // cameraId is found in public camera IDs advertised by the
1110 // provider.
1111 return false;
1112 }
1113 }
1114 }
1115
1116 for (auto& provider : mProviders) {
1117 for (auto& deviceInfo : provider->mDevices) {
1118 CameraMetadata info;
1119 status_t res = deviceInfo->getCameraCharacteristics(&info);
1120 if (res != OK) {
1121 ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
1122 deviceInfo->mId.c_str());
1123 return false;
1124 }
1125
1126 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001127 if (deviceInfo->mIsLogicalCamera) {
1128 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
1129 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001130 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
1131 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
1132 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
1133 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
1134 __FUNCTION__, deviceVersion, cameraId.c_str());
1135 return false;
1136 } else {
1137 return true;
1138 }
1139 }
1140 }
1141 }
1142 }
1143
1144 return false;
1145}
1146
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001147status_t CameraProviderManager::addProviderLocked(const std::string& newProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001148 for (const auto& providerInfo : mProviders) {
1149 if (providerInfo->mProviderName == newProvider) {
1150 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
1151 newProvider.c_str());
1152 return ALREADY_EXISTS;
1153 }
1154 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001155
1156 sp<provider::V2_4::ICameraProvider> interface;
1157 interface = mServiceProxy->getService(newProvider);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001158
1159 if (interface == nullptr) {
Yin-Chia Yeh177b0c12019-06-25 10:53:03 -07001160 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
1161 newProvider.c_str());
1162 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001163 }
1164
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001165 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001166 status_t res = providerInfo->initialize(interface, mDeviceState);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001167 if (res != OK) {
1168 return res;
1169 }
1170
1171 mProviders.push_back(providerInfo);
1172
1173 return OK;
1174}
1175
1176status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -07001177 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001178 std::unique_lock<std::mutex> lock(mInterfaceMutex);
1179 std::vector<String8> removedDeviceIds;
1180 status_t res = NAME_NOT_FOUND;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001181 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
1182 if ((*it)->mProviderName == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001183 removedDeviceIds.reserve((*it)->mDevices.size());
1184 for (auto& deviceInfo : (*it)->mDevices) {
1185 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
1186 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001187 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001188 res = OK;
1189 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001190 }
1191 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001192 if (res != OK) {
1193 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1194 provider.c_str());
1195 } else {
1196 // Inform camera service of loss of presence for all the devices from this provider,
1197 // without lock held for reentrancy
1198 sp<StatusListener> listener = getStatusListener();
1199 if (listener != nullptr) {
1200 lock.unlock();
1201 for (auto& id : removedDeviceIds) {
1202 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1203 }
1204 }
1205 }
1206 return res;
1207}
1208
1209sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1210 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001211}
1212
1213/**** Methods for ProviderInfo ****/
1214
1215
1216CameraProviderManager::ProviderInfo::ProviderInfo(
1217 const std::string &providerName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001218 CameraProviderManager *manager) :
1219 mProviderName(providerName),
Emilian Peev71c73a22017-03-21 16:35:51 +00001220 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001221 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001222 mManager(manager) {
1223 (void) mManager;
1224}
1225
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001226status_t CameraProviderManager::ProviderInfo::initialize(
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001227 sp<provider::V2_4::ICameraProvider>& interface,
1228 hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001229 status_t res = parseProviderName(mProviderName, &mType, &mId);
1230 if (res != OK) {
1231 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1232 return BAD_VALUE;
1233 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001234 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001235 mProviderName.c_str(), interface->isRemote());
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001236
1237 // Determine minor version
1238 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1239 if (castResult.isOk()) {
1240 mMinorVersion = 5;
1241 } else {
1242 mMinorVersion = 4;
1243 }
1244
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001245 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1246 // before setCallback returns
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001247 hardware::Return<Status> status = interface->setCallback(this);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001248 if (!status.isOk()) {
1249 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1250 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1251 return DEAD_OBJECT;
1252 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001253 if (status != Status::OK) {
1254 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1255 __FUNCTION__, mProviderName.c_str());
1256 return mapToStatusT(status);
1257 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001258
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001259 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001260 if (!linked.isOk()) {
1261 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1262 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1263 return DEAD_OBJECT;
1264 } else if (!linked) {
1265 ALOGW("%s: Unable to link to provider '%s' death notifications",
1266 __FUNCTION__, mProviderName.c_str());
1267 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001268
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001269 if (!kEnableLazyHal) {
1270 // Save HAL reference indefinitely
1271 mSavedInterface = interface;
1272 } else {
1273 mActiveInterface = interface;
1274 }
1275
1276 ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
1277 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1278 notifyDeviceStateChange(currentDeviceState);
1279
1280 res = setUpVendorTags();
1281 if (res != OK) {
1282 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1283 __FUNCTION__, mProviderName.c_str());
1284 return res;
1285 }
1286
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001287 // Get initial list of camera devices, if any
1288 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001289 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001290 Status idStatus,
1291 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1292 status = idStatus;
1293 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001294 for (auto& name : cameraDeviceNames) {
1295 uint16_t major, minor;
1296 std::string type, id;
1297 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1298 if (res != OK) {
1299 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1300 status = Status::INTERNAL_ERROR;
1301 } else {
1302 devices.push_back(name);
1303 mProviderPublicCameraIds.push_back(id);
1304 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001305 }
1306 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001307 if (!ret.isOk()) {
1308 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1309 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1310 return DEAD_OBJECT;
1311 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001312 if (status != Status::OK) {
1313 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1314 __FUNCTION__, mProviderName.c_str());
1315 return mapToStatusT(status);
1316 }
1317
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001318 ret = interface->isSetTorchModeSupported(
1319 [this](auto status, bool supported) {
1320 if (status == Status::OK) {
1321 mSetTorchModeSupported = supported;
1322 }
1323 });
1324 if (!ret.isOk()) {
1325 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1326 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1327 return DEAD_OBJECT;
1328 }
1329
1330 mIsRemote = interface->isRemote();
1331
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001332 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001333 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001334 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001335 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001336 if (res != OK) {
1337 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1338 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001339 continue;
1340 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001341 }
1342
1343 ALOGI("Camera provider %s ready with %zu camera devices",
1344 mProviderName.c_str(), mDevices.size());
1345
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001346 mInitialized = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001347 return OK;
1348}
1349
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001350const sp<provider::V2_4::ICameraProvider>
1351CameraProviderManager::ProviderInfo::startProviderInterface() {
1352 ATRACE_CALL();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001353 ALOGV("Request to start camera provider: %s", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001354 if (mSavedInterface != nullptr) {
1355 return mSavedInterface;
1356 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001357 if (!kEnableLazyHal) {
1358 ALOGE("Bad provider state! Should not be here on a non-lazy HAL!");
1359 return nullptr;
1360 }
1361
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001362 auto interface = mActiveInterface.promote();
1363 if (interface == nullptr) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001364 ALOGI("Camera HAL provider needs restart, calling getService(%s)", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001365 interface = mManager->mServiceProxy->getService(mProviderName);
1366 interface->setCallback(this);
1367 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
1368 if (!linked.isOk()) {
1369 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1370 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1371 mManager->removeProvider(mProviderName);
1372 return nullptr;
1373 } else if (!linked) {
1374 ALOGW("%s: Unable to link to provider '%s' death notifications",
1375 __FUNCTION__, mProviderName.c_str());
1376 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001377 // Send current device state
1378 if (mMinorVersion >= 5) {
1379 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1380 if (castResult.isOk()) {
1381 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1382 if (interface_2_5 != nullptr) {
1383 ALOGV("%s: Initial device state for %s: 0x %" PRIx64,
1384 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1385 interface_2_5->notifyDeviceStateChange(mDeviceState);
1386 }
1387 }
1388 }
1389
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001390 mActiveInterface = interface;
1391 } else {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001392 ALOGV("Camera provider (%s) already in use. Re-using instance.", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001393 }
1394 return interface;
1395}
1396
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001397const std::string& CameraProviderManager::ProviderInfo::getType() const {
1398 return mType;
1399}
1400
1401status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1402 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1403
1404 ALOGI("Enumerating new camera device: %s", name.c_str());
1405
1406 uint16_t major, minor;
1407 std::string type, id;
1408
1409 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1410 if (res != OK) {
1411 return res;
1412 }
1413 if (type != mType) {
1414 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1415 type.c_str(), mType.c_str());
1416 return BAD_VALUE;
1417 }
1418 if (mManager->isValidDeviceLocked(id, major)) {
1419 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1420 name.c_str(), id.c_str(), major);
1421 return BAD_VALUE;
1422 }
1423
1424 std::unique_ptr<DeviceInfo> deviceInfo;
1425 switch (major) {
1426 case 1:
Emilian Peev71c73a22017-03-21 16:35:51 +00001427 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
1428 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001429 break;
1430 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001431 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1432 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001433 break;
1434 default:
1435 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1436 name.c_str(), major);
1437 return BAD_VALUE;
1438 }
1439 if (deviceInfo == nullptr) return BAD_VALUE;
1440 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001441 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001442
1443 mDevices.push_back(std::move(deviceInfo));
1444
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001445 mUniqueCameraIds.insert(id);
1446 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001447 // addDevice can be called more than once for the same camera id if HAL
1448 // supports openLegacy.
1449 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1450 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1451 mUniqueAPI1CompatibleCameraIds.push_back(id);
1452 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001453 }
1454
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001455 if (parsedId != nullptr) {
1456 *parsedId = id;
1457 }
1458 return OK;
1459}
1460
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001461void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1462 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1463 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001464 mUniqueCameraIds.erase(id);
1465 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001466 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
1467 mUniqueAPI1CompatibleCameraIds.begin(),
1468 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001469 }
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001470 mDevices.erase(it);
1471 break;
1472 }
1473 }
1474}
1475
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001476status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001477 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
1478 mProviderName.c_str(),
1479 mMinorVersion,
1480 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001481 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001482
1483 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001484 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1485 device->mVersion.get_major(), device->mVersion.get_minor());
1486 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1487 if (device->mResourceCost.conflictingDevices.size() == 0) {
1488 dprintf(fd, " Conflicting devices: None\n");
1489 } else {
1490 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001491 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001492 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001493 device->mResourceCost.conflictingDevices[i].c_str());
1494 }
1495 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001496 dprintf(fd, " API1 info:\n");
1497 dprintf(fd, " Has a flash unit: %s\n",
1498 device->hasFlashUnit() ? "true" : "false");
1499 hardware::CameraInfo info;
1500 status_t res = device->getCameraInfo(&info);
1501 if (res != OK) {
1502 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1503 strerror(-res), res);
1504 } else {
1505 dprintf(fd, " Facing: %s\n",
1506 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1507 dprintf(fd, " Orientation: %d\n", info.orientation);
1508 }
1509 CameraMetadata info2;
1510 res = device->getCameraCharacteristics(&info2);
1511 if (res == INVALID_OPERATION) {
1512 dprintf(fd, " API2 not directly supported\n");
1513 } else if (res != OK) {
1514 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1515 strerror(-res), res);
1516 } else {
1517 dprintf(fd, " API2 camera characteristics:\n");
1518 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1519 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001520
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001521 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001522 if (device->mIsLogicalCamera) {
1523 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001524 // Skip if physical id is an independent camera
1525 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1526 != mProviderPublicCameraIds.end()) {
1527 continue;
1528 }
1529
1530 CameraMetadata physicalInfo;
1531 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1532 if (status == OK) {
1533 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1534 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1535 }
1536 }
1537 }
1538
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001539 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1540 device->mVersion.get_major(), device->mVersion.get_minor());
1541 res = device->dumpState(fd);
1542 if (res != OK) {
1543 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1544 device->mName.c_str(), strerror(-res), res);
1545 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001546 }
1547 return OK;
1548}
1549
1550hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1551 const hardware::hidl_string& cameraDeviceName,
1552 CameraDeviceStatus newStatus) {
1553 sp<StatusListener> listener;
1554 std::string id;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001555 bool initialized = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001556 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001557 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001558 bool known = false;
1559 for (auto& deviceInfo : mDevices) {
1560 if (deviceInfo->mName == cameraDeviceName) {
1561 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
1562 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
1563 deviceInfo->mStatus = newStatus;
1564 // TODO: Handle device removal (NOT_PRESENT)
1565 id = deviceInfo->mId;
1566 known = true;
1567 break;
1568 }
1569 }
1570 // Previously unseen device; status must not be NOT_PRESENT
1571 if (!known) {
1572 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1573 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
1574 mProviderName.c_str(), cameraDeviceName.c_str());
1575 return hardware::Void();
1576 }
1577 addDevice(cameraDeviceName, newStatus, &id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001578 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1579 removeDevice(id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001580 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001581 listener = mManager->getStatusListener();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001582 initialized = mInitialized;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001583 }
1584 // Call without lock held to allow reentrancy into provider manager
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001585 // Don't send the callback if providerInfo hasn't been initialized.
1586 // CameraService will initialize device status after provider is
1587 // initialized
1588 if (listener != nullptr && initialized) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001589 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
1590 }
1591 return hardware::Void();
1592}
1593
1594hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
1595 const hardware::hidl_string& cameraDeviceName,
1596 TorchModeStatus newStatus) {
1597 sp<StatusListener> listener;
1598 std::string id;
1599 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001600 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
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 torch status is now %s", cameraDeviceName.c_str(),
1605 torchStatusToString(newStatus));
1606 id = deviceInfo->mId;
1607 known = true;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001608 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
1609 mManager->removeRef(DeviceMode::TORCH, id);
1610 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001611 break;
1612 }
1613 }
1614 if (!known) {
1615 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
1616 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
1617 return hardware::Void();
1618 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001619 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001620 }
1621 // Call without lock held to allow reentrancy into provider manager
1622 if (listener != nullptr) {
1623 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
1624 }
1625 return hardware::Void();
1626}
1627
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001628void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
1629 const wp<hidl::base::V1_0::IBase>& who) {
1630 (void) who;
1631 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
1632 if (cookie != mId) {
1633 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
1634 __FUNCTION__, cookie, mId);
1635 }
1636 mManager->removeProvider(mProviderName);
1637}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001638
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001639status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
1640 if (mVendorTagDescriptor != nullptr)
1641 return OK;
1642
1643 hardware::hidl_vec<VendorTagSection> vts;
1644 Status status;
1645 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001646 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1647 if (interface == nullptr) {
1648 return DEAD_OBJECT;
1649 }
1650 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001651 [&](auto s, const auto& vendorTagSecs) {
1652 status = s;
1653 if (s == Status::OK) {
1654 vts = vendorTagSecs;
1655 }
1656 });
1657 if (!ret.isOk()) {
1658 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
1659 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1660 return DEAD_OBJECT;
1661 }
1662 if (status != Status::OK) {
1663 return mapToStatusT(status);
1664 }
1665
1666 // Read all vendor tag definitions into a descriptor
1667 status_t res;
1668 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
1669 != OK) {
1670 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
1671 "received error %s (%d). Camera clients will not be able to use"
1672 "vendor tags", __FUNCTION__, strerror(res), res);
1673 return res;
1674 }
1675
1676 return OK;
1677}
1678
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001679status_t CameraProviderManager::ProviderInfo::notifyDeviceStateChange(
1680 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
1681 mDeviceState = newDeviceState;
1682 if (mMinorVersion >= 5) {
1683 // Check if the provider is currently active - not going to start it up for this notification
1684 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
1685 if (interface != nullptr) {
1686 // Send current device state
1687 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1688 if (castResult.isOk()) {
1689 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1690 if (interface_2_5 != nullptr) {
1691 interface_2_5->notifyDeviceStateChange(mDeviceState);
1692 }
1693 }
1694 }
1695 }
1696 return OK;
1697}
1698
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001699template<class DeviceInfoT>
1700std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
1701 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00001702 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001703 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001704 Status status;
1705
1706 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001707 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001708 if (cameraInterface == nullptr) return nullptr;
1709
1710 CameraResourceCost resourceCost;
1711 cameraInterface->getResourceCost([&status, &resourceCost](
1712 Status s, CameraResourceCost cost) {
1713 status = s;
1714 resourceCost = cost;
1715 });
1716 if (status != Status::OK) {
1717 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
1718 name.c_str(), statusToString(status));
1719 return nullptr;
1720 }
Shuzhen Wang47283692018-04-24 18:05:02 -07001721
1722 for (auto& conflictName : resourceCost.conflictingDevices) {
1723 uint16_t major, minor;
1724 std::string type, id;
1725 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
1726 if (res != OK) {
1727 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
1728 return nullptr;
1729 }
1730 conflictName = id;
1731 }
1732
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001733 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001734 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001735 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001736}
1737
1738template<class InterfaceT>
1739sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001740CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001741 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1742 name.c_str(), InterfaceT::version.get_major());
1743 return nullptr;
1744}
1745
1746template<>
1747sp<device::V1_0::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001748CameraProviderManager::ProviderInfo::startDeviceInterface
1749 <device::V1_0::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001750 Status status;
1751 sp<device::V1_0::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001752 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001753 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1754 if (interface == nullptr) {
1755 return nullptr;
1756 }
1757 ret = interface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001758 Status s, sp<device::V1_0::ICameraDevice> interface) {
1759 status = s;
1760 cameraInterface = interface;
1761 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001762 if (!ret.isOk()) {
1763 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1764 __FUNCTION__, name.c_str(), ret.description().c_str());
1765 return nullptr;
1766 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001767 if (status != Status::OK) {
1768 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1769 name.c_str(), statusToString(status));
1770 return nullptr;
1771 }
1772 return cameraInterface;
1773}
1774
1775template<>
1776sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001777CameraProviderManager::ProviderInfo::startDeviceInterface
1778 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001779 Status status;
1780 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001781 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001782 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1783 if (interface == nullptr) {
1784 return nullptr;
1785 }
1786 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001787 Status s, sp<device::V3_2::ICameraDevice> interface) {
1788 status = s;
1789 cameraInterface = interface;
1790 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001791 if (!ret.isOk()) {
1792 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1793 __FUNCTION__, name.c_str(), ret.description().c_str());
1794 return nullptr;
1795 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001796 if (status != Status::OK) {
1797 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1798 name.c_str(), statusToString(status));
1799 return nullptr;
1800 }
1801 return cameraInterface;
1802}
1803
1804CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
1805
1806template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001807sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
1808 sp<InterfaceT> device;
1809 ATRACE_CALL();
1810 if (mSavedInterface == nullptr) {
1811 device = mParentProvider->startDeviceInterface<InterfaceT>(mName);
1812 } else {
1813 device = (InterfaceT *) mSavedInterface.get();
1814 }
1815 return device;
1816}
1817
1818template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001819status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
1820 bool enabled) {
1821 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
1822 return mapToStatusT(s);
1823}
1824
1825CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001826 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001827 uint16_t minorVersion,
1828 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001829 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001830 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001831 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001832 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001833 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001834 // Get default parameters and initialize flash unit availability
1835 // Requires powering on the camera device
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001836 hardware::Return<Status> status = interface->open(nullptr);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001837 if (!status.isOk()) {
1838 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001839 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001840 return;
1841 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001842 if (status != Status::OK) {
1843 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001844 id.c_str(), CameraProviderManager::statusToString(status));
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001845 return;
1846 }
1847 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001848 ret = interface->getParameters([this](const hardware::hidl_string& parms) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001849 mDefaultParameters.unflatten(String8(parms.c_str()));
1850 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001851 if (!ret.isOk()) {
1852 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001853 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001854 return;
1855 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001856 const char *flashMode =
1857 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1858 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
1859 mHasFlashUnit = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001860 }
1861
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001862 status_t res = cacheCameraInfo(interface);
1863 if (res != OK) {
1864 ALOGE("%s: Could not cache CameraInfo", __FUNCTION__);
1865 return;
1866 }
1867
1868 ret = interface->close();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001869 if (!ret.isOk()) {
1870 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001871 __FUNCTION__, id.c_str(), status.description().c_str());
1872 }
1873
1874 if (!kEnableLazyHal) {
1875 // Save HAL reference indefinitely
1876 mSavedInterface = interface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001877 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001878}
1879
1880CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
1881
1882status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001883 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001884}
1885
1886status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
1887 hardware::CameraInfo *info) const {
1888 if (info == nullptr) return BAD_VALUE;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001889 *info = mInfo;
1890 return OK;
1891}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001892
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001893status_t CameraProviderManager::ProviderInfo::DeviceInfo1::cacheCameraInfo(
1894 sp<CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT> interface) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001895 Status status;
1896 device::V1_0::CameraInfo cInfo;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001897 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001898 ret = interface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001899 status = s;
1900 cInfo = camInfo;
1901 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001902 if (!ret.isOk()) {
1903 ALOGE("%s: Transaction error reading camera info from device %s: %s",
1904 __FUNCTION__, mId.c_str(), ret.description().c_str());
1905 return DEAD_OBJECT;
1906 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001907 if (status != Status::OK) {
1908 return mapToStatusT(status);
1909 }
1910
1911 switch(cInfo.facing) {
1912 case device::V1_0::CameraFacing::BACK:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001913 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001914 break;
1915 case device::V1_0::CameraFacing::EXTERNAL:
1916 // Map external to front for legacy API
1917 case device::V1_0::CameraFacing::FRONT:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001918 mInfo.facing = hardware::CAMERA_FACING_FRONT;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001919 break;
1920 default:
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001921 ALOGW("%s: Device %s: Unknown camera facing: %d",
1922 __FUNCTION__, mId.c_str(), cInfo.facing);
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001923 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001924 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001925 mInfo.orientation = cInfo.orientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001926
1927 return OK;
1928}
1929
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001930status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001931 native_handle_t* handle = native_handle_create(1,0);
1932 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001933 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1934 if (interface == nullptr) {
1935 return DEAD_OBJECT;
1936 }
1937 hardware::Return<Status> s = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001938 native_handle_delete(handle);
1939 if (!s.isOk()) {
1940 return INVALID_OPERATION;
1941 }
1942 return mapToStatusT(s);
1943}
1944
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001945CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001946 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001947 uint16_t minorVersion,
1948 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001949 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001950 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001951 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001952 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001953 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001954 // Get camera characteristics and initialize flash unit availability
1955 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001956 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001957 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001958 device::V3_2::CameraMetadata metadata) {
1959 status = s;
1960 if (s == Status::OK) {
1961 camera_metadata_t *buffer =
1962 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07001963 size_t expectedSize = metadata.size();
1964 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1965 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1966 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1967 mCameraCharacteristics = buffer;
1968 } else {
1969 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1970 status = Status::INTERNAL_ERROR;
1971 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001972 }
1973 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001974 if (!ret.isOk()) {
1975 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001976 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001977 ret.description().c_str());
1978 return;
1979 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001980 if (status != Status::OK) {
1981 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001982 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001983 return;
1984 }
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001985
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001986 mSystemCameraKind = getSystemCameraKind();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001987
Shuzhen Wang268a1362018-10-16 16:32:59 -07001988 status_t res = fixupMonochromeTags();
1989 if (OK != res) {
1990 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
1991 __FUNCTION__, strerror(-res), res);
1992 return;
1993 }
Emilian Peeva1185162019-01-30 16:41:43 -08001994 auto stat = addDynamicDepthTags();
1995 if (OK != stat) {
1996 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-stat),
1997 stat);
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001998 }
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001999 res = deriveHeicTags();
2000 if (OK != res) {
2001 ALOGE("%s: Unable to derive HEIC tags based on camera and media capabilities: %s (%d)",
2002 __FUNCTION__, strerror(-res), res);
2003 }
2004
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002005 camera_metadata_entry flashAvailable =
2006 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
2007 if (flashAvailable.count == 1 &&
2008 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
2009 mHasFlashUnit = true;
2010 } else {
2011 mHasFlashUnit = false;
2012 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002013
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002014 queryPhysicalCameraIds();
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08002015
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002016 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002017 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002018 if (!castResult.isOk()) {
2019 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
2020 return;
2021 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002022 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002023 if (interface_3_5 == nullptr) {
2024 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
2025 return;
2026 }
2027
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002028 if (mIsLogicalCamera) {
2029 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002030 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
2031 mPublicCameraIds.end()) {
2032 continue;
2033 }
2034
2035 hardware::hidl_string hidlId(id);
2036 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
2037 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
2038 status = s;
2039 if (s == Status::OK) {
2040 camera_metadata_t *buffer =
2041 reinterpret_cast<camera_metadata_t*>(metadata.data());
2042 size_t expectedSize = metadata.size();
2043 int res = validate_camera_metadata_structure(buffer, &expectedSize);
2044 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
2045 set_camera_metadata_vendor_id(buffer, mProviderTagid);
2046 mPhysicalCameraCharacteristics[id] = buffer;
2047 } else {
2048 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
2049 status = Status::INTERNAL_ERROR;
2050 }
2051 }
2052 });
2053
2054 if (!ret.isOk()) {
2055 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002056 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002057 return;
2058 }
2059 if (status != Status::OK) {
2060 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
2061 __FUNCTION__, id.c_str(), mId.c_str(),
2062 CameraProviderManager::statusToString(status), status);
2063 return;
2064 }
2065 }
2066 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002067
2068 if (!kEnableLazyHal) {
2069 // Save HAL reference indefinitely
2070 mSavedInterface = interface;
2071 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002072}
2073
2074CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
2075
2076status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002077 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002078}
2079
2080status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
2081 hardware::CameraInfo *info) const {
2082 if (info == nullptr) return BAD_VALUE;
2083
2084 camera_metadata_ro_entry facing =
2085 mCameraCharacteristics.find(ANDROID_LENS_FACING);
2086 if (facing.count == 1) {
2087 switch (facing.data.u8[0]) {
2088 case ANDROID_LENS_FACING_BACK:
2089 info->facing = hardware::CAMERA_FACING_BACK;
2090 break;
2091 case ANDROID_LENS_FACING_EXTERNAL:
2092 // Map external to front for legacy API
2093 case ANDROID_LENS_FACING_FRONT:
2094 info->facing = hardware::CAMERA_FACING_FRONT;
2095 break;
2096 }
2097 } else {
2098 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
2099 return NAME_NOT_FOUND;
2100 }
2101
2102 camera_metadata_ro_entry orientation =
2103 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
2104 if (orientation.count == 1) {
2105 info->orientation = orientation.data.i32[0];
2106 } else {
2107 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
2108 return NAME_NOT_FOUND;
2109 }
2110
2111 return OK;
2112}
Emilian Peevf53f66e2017-04-11 14:29:43 +01002113bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
Shuzhen Wang7a7e6342019-05-31 16:28:21 -07002114 // Do not advertise NIR cameras to API1 camera app.
2115 camera_metadata_ro_entry cfa = mCameraCharacteristics.find(
2116 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
2117 if (cfa.count == 1 && cfa.data.u8[0] == ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_NIR) {
2118 return false;
2119 }
2120
Emilian Peevf53f66e2017-04-11 14:29:43 +01002121 bool isBackwardCompatible = false;
2122 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
2123 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
2124 for (size_t i = 0; i < caps.count; i++) {
2125 if (caps.data.u8[i] ==
2126 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2127 isBackwardCompatible = true;
2128 break;
2129 }
2130 }
2131
2132 return isBackwardCompatible;
2133}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002134
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002135status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002136 native_handle_t* handle = native_handle_create(1,0);
2137 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002138 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
2139 if (interface == nullptr) {
2140 return DEAD_OBJECT;
2141 }
2142 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08002143 native_handle_delete(handle);
2144 if (!ret.isOk()) {
2145 return INVALID_OPERATION;
2146 }
2147 return OK;
2148}
2149
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002150status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
2151 CameraMetadata *characteristics) const {
2152 if (characteristics == nullptr) return BAD_VALUE;
2153
2154 *characteristics = mCameraCharacteristics;
2155 return OK;
2156}
2157
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002158status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
2159 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
2160 if (characteristics == nullptr) return BAD_VALUE;
2161 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
2162 mPhysicalCameraCharacteristics.end()) {
2163 return NAME_NOT_FOUND;
2164 }
2165
2166 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
2167 return OK;
2168}
2169
Emilian Peev35ae8262018-11-08 13:11:32 +00002170status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
2171 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002172 bool *status /*out*/) {
2173
2174 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
2175 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
2176 if (interface == nullptr) {
2177 return DEAD_OBJECT;
2178 }
2179 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Emilian Peev35ae8262018-11-08 13:11:32 +00002180 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
2181 if (interface_3_5 == nullptr) {
2182 return INVALID_OPERATION;
2183 }
2184
2185 status_t res;
2186 Status callStatus;
2187 auto ret = interface_3_5->isStreamCombinationSupported(configuration,
2188 [&callStatus, &status] (Status s, bool combStatus) {
2189 callStatus = s;
2190 *status = combStatus;
2191 });
2192 if (ret.isOk()) {
2193 switch (callStatus) {
2194 case Status::OK:
2195 // Expected case, do nothing.
2196 res = OK;
2197 break;
2198 case Status::METHOD_NOT_SUPPORTED:
2199 res = INVALID_OPERATION;
2200 break;
2201 default:
2202 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
2203 res = UNKNOWN_ERROR;
2204 }
2205 } else {
2206 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
2207 res = UNKNOWN_ERROR;
2208 }
2209
2210 return res;
2211}
2212
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002213status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
2214 std::string *type, uint32_t *id) {
2215 // Format must be "<type>/<id>"
2216#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
2217 "Should match '<type>/<id>' - "
2218
2219 if (!type || !id) return INVALID_OPERATION;
2220
2221 std::string::size_type slashIdx = name.find('/');
2222 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
2223 ALOGE(ERROR_MSG_PREFIX
2224 "does not have / separator between type and id",
2225 __FUNCTION__, name.c_str());
2226 return BAD_VALUE;
2227 }
2228
2229 std::string typeVal = name.substr(0, slashIdx);
2230
2231 char *endPtr;
2232 errno = 0;
2233 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
2234 if (errno != 0) {
2235 ALOGE(ERROR_MSG_PREFIX
2236 "cannot parse provider id as an integer: %s (%d)",
2237 __FUNCTION__, name.c_str(), strerror(errno), errno);
2238 return BAD_VALUE;
2239 }
2240 if (endPtr != name.c_str() + name.size()) {
2241 ALOGE(ERROR_MSG_PREFIX
2242 "provider id has unexpected length",
2243 __FUNCTION__, name.c_str());
2244 return BAD_VALUE;
2245 }
2246 if (idVal < 0) {
2247 ALOGE(ERROR_MSG_PREFIX
2248 "id is negative: %ld",
2249 __FUNCTION__, name.c_str(), idVal);
2250 return BAD_VALUE;
2251 }
2252
2253#undef ERROR_MSG_PREFIX
2254
2255 *type = typeVal;
2256 *id = static_cast<uint32_t>(idVal);
2257
2258 return OK;
2259}
2260
Emilian Peev71c73a22017-03-21 16:35:51 +00002261metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
2262 const std::string &name) {
2263 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
2264 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
2265 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
2266 ret = 0;
2267 }
2268
2269 return ret;
2270}
2271
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002272status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
2273 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
2274
2275 // Format must be "device@<major>.<minor>/<type>/<id>"
2276
2277#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
2278 "Should match 'device@<major>.<minor>/<type>/<id>' - "
2279
2280 if (!major || !minor || !type || !id) return INVALID_OPERATION;
2281
2282 // Verify starting prefix
2283 const char expectedPrefix[] = "device@";
2284
2285 if (name.find(expectedPrefix) != 0) {
2286 ALOGE(ERROR_MSG_PREFIX
2287 "does not start with '%s'",
2288 __FUNCTION__, name.c_str(), expectedPrefix);
2289 return BAD_VALUE;
2290 }
2291
2292 // Extract major/minor versions
2293 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
2294 std::string::size_type dotIdx = name.find('.', atIdx);
2295 if (dotIdx == std::string::npos) {
2296 ALOGE(ERROR_MSG_PREFIX
2297 "does not have @<major>. version section",
2298 __FUNCTION__, name.c_str());
2299 return BAD_VALUE;
2300 }
2301 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
2302 if (typeSlashIdx == std::string::npos) {
2303 ALOGE(ERROR_MSG_PREFIX
2304 "does not have .<minor>/ version section",
2305 __FUNCTION__, name.c_str());
2306 return BAD_VALUE;
2307 }
2308
2309 char *endPtr;
2310 errno = 0;
2311 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
2312 if (errno != 0) {
2313 ALOGE(ERROR_MSG_PREFIX
2314 "cannot parse major version: %s (%d)",
2315 __FUNCTION__, name.c_str(), strerror(errno), errno);
2316 return BAD_VALUE;
2317 }
2318 if (endPtr != name.c_str() + dotIdx) {
2319 ALOGE(ERROR_MSG_PREFIX
2320 "major version has unexpected length",
2321 __FUNCTION__, name.c_str());
2322 return BAD_VALUE;
2323 }
2324 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
2325 if (errno != 0) {
2326 ALOGE(ERROR_MSG_PREFIX
2327 "cannot parse minor version: %s (%d)",
2328 __FUNCTION__, name.c_str(), strerror(errno), errno);
2329 return BAD_VALUE;
2330 }
2331 if (endPtr != name.c_str() + typeSlashIdx) {
2332 ALOGE(ERROR_MSG_PREFIX
2333 "minor version has unexpected length",
2334 __FUNCTION__, name.c_str());
2335 return BAD_VALUE;
2336 }
2337 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
2338 ALOGE(ERROR_MSG_PREFIX
2339 "major/minor version is out of range of uint16_t: %ld.%ld",
2340 __FUNCTION__, name.c_str(), majorVal, minorVal);
2341 return BAD_VALUE;
2342 }
2343
2344 // Extract type and id
2345
2346 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
2347 if (instanceSlashIdx == std::string::npos) {
2348 ALOGE(ERROR_MSG_PREFIX
2349 "does not have /<type>/ component",
2350 __FUNCTION__, name.c_str());
2351 return BAD_VALUE;
2352 }
2353 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
2354
2355 if (instanceSlashIdx == name.size() - 1) {
2356 ALOGE(ERROR_MSG_PREFIX
2357 "does not have an /<id> component",
2358 __FUNCTION__, name.c_str());
2359 return BAD_VALUE;
2360 }
2361 std::string idVal = name.substr(instanceSlashIdx + 1);
2362
2363#undef ERROR_MSG_PREFIX
2364
2365 *major = static_cast<uint16_t>(majorVal);
2366 *minor = static_cast<uint16_t>(minorVal);
2367 *type = typeVal;
2368 *id = idVal;
2369
2370 return OK;
2371}
2372
2373
2374
2375CameraProviderManager::ProviderInfo::~ProviderInfo() {
2376 // Destruction of ProviderInfo is only supposed to happen when the respective
2377 // CameraProvider interface dies, so do not unregister callbacks.
2378
2379}
2380
2381status_t CameraProviderManager::mapToStatusT(const Status& s) {
2382 switch(s) {
2383 case Status::OK:
2384 return OK;
2385 case Status::ILLEGAL_ARGUMENT:
2386 return BAD_VALUE;
2387 case Status::CAMERA_IN_USE:
2388 return -EBUSY;
2389 case Status::MAX_CAMERAS_IN_USE:
2390 return -EUSERS;
2391 case Status::METHOD_NOT_SUPPORTED:
2392 return UNKNOWN_TRANSACTION;
2393 case Status::OPERATION_NOT_SUPPORTED:
2394 return INVALID_OPERATION;
2395 case Status::CAMERA_DISCONNECTED:
2396 return DEAD_OBJECT;
2397 case Status::INTERNAL_ERROR:
2398 return INVALID_OPERATION;
2399 }
2400 ALOGW("Unexpected HAL status code %d", s);
2401 return INVALID_OPERATION;
2402}
2403
2404const char* CameraProviderManager::statusToString(const Status& s) {
2405 switch(s) {
2406 case Status::OK:
2407 return "OK";
2408 case Status::ILLEGAL_ARGUMENT:
2409 return "ILLEGAL_ARGUMENT";
2410 case Status::CAMERA_IN_USE:
2411 return "CAMERA_IN_USE";
2412 case Status::MAX_CAMERAS_IN_USE:
2413 return "MAX_CAMERAS_IN_USE";
2414 case Status::METHOD_NOT_SUPPORTED:
2415 return "METHOD_NOT_SUPPORTED";
2416 case Status::OPERATION_NOT_SUPPORTED:
2417 return "OPERATION_NOT_SUPPORTED";
2418 case Status::CAMERA_DISCONNECTED:
2419 return "CAMERA_DISCONNECTED";
2420 case Status::INTERNAL_ERROR:
2421 return "INTERNAL_ERROR";
2422 }
2423 ALOGW("Unexpected HAL status code %d", s);
2424 return "UNKNOWN_ERROR";
2425}
2426
2427const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
2428 switch(s) {
2429 case CameraDeviceStatus::NOT_PRESENT:
2430 return "NOT_PRESENT";
2431 case CameraDeviceStatus::PRESENT:
2432 return "PRESENT";
2433 case CameraDeviceStatus::ENUMERATING:
2434 return "ENUMERATING";
2435 }
2436 ALOGW("Unexpected HAL device status code %d", s);
2437 return "UNKNOWN_STATUS";
2438}
2439
2440const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
2441 switch(s) {
2442 case TorchModeStatus::NOT_AVAILABLE:
2443 return "NOT_AVAILABLE";
2444 case TorchModeStatus::AVAILABLE_OFF:
2445 return "AVAILABLE_OFF";
2446 case TorchModeStatus::AVAILABLE_ON:
2447 return "AVAILABLE_ON";
2448 }
2449 ALOGW("Unexpected HAL torch mode status code %d", s);
2450 return "UNKNOWN_STATUS";
2451}
2452
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002453
2454status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002455 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002456 /*out*/
2457 sp<VendorTagDescriptor>& descriptor) {
2458
2459 int tagCount = 0;
2460
2461 for (size_t s = 0; s < vts.size(); s++) {
2462 tagCount += vts[s].tags.size();
2463 }
2464
2465 if (tagCount < 0 || tagCount > INT32_MAX) {
2466 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
2467 return BAD_VALUE;
2468 }
2469
2470 Vector<uint32_t> tagArray;
2471 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
2472 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
2473
2474
2475 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
2476 desc->mTagCount = tagCount;
2477
2478 SortedVector<String8> sections;
2479 KeyedVector<uint32_t, String8> tagToSectionMap;
2480
2481 int idx = 0;
2482 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002483 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002484 const char *sectionName = section.sectionName.c_str();
2485 if (sectionName == NULL) {
2486 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
2487 return BAD_VALUE;
2488 }
2489 String8 sectionString(sectionName);
2490 sections.add(sectionString);
2491
2492 for (size_t j = 0; j < section.tags.size(); j++) {
2493 uint32_t tag = section.tags[j].tagId;
2494 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
2495 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
2496 return BAD_VALUE;
2497 }
2498
2499 tagArray.editItemAt(idx++) = section.tags[j].tagId;
2500
2501 const char *tagName = section.tags[j].tagName.c_str();
2502 if (tagName == NULL) {
2503 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
2504 return BAD_VALUE;
2505 }
2506 desc->mTagToNameMap.add(tag, String8(tagName));
2507 tagToSectionMap.add(tag, sectionString);
2508
2509 int tagType = (int) section.tags[j].tagType;
2510 if (tagType < 0 || tagType >= NUM_TYPES) {
2511 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
2512 return BAD_VALUE;
2513 }
2514 desc->mTagToTypeMap.add(tag, tagType);
2515 }
2516 }
2517
2518 desc->mSections = sections;
2519
2520 for (size_t i = 0; i < tagArray.size(); ++i) {
2521 uint32_t tag = tagArray[i];
2522 String8 sectionString = tagToSectionMap.valueFor(tag);
2523
2524 // Set up tag to section index map
2525 ssize_t index = sections.indexOf(sectionString);
2526 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
2527 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
2528
2529 // Set up reverse mapping
2530 ssize_t reverseIndex = -1;
2531 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
2532 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
2533 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
2534 }
2535 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
2536 }
2537
George Burgess IVa0b84962017-08-29 17:46:19 -07002538 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002539 return OK;
2540}
2541
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002542status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
2543 CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002544 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
2545 if (deviceInfo != nullptr) {
2546 return deviceInfo->getCameraCharacteristics(characteristics);
2547 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002548
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002549 // Find hidden physical camera characteristics
2550 for (auto& provider : mProviders) {
2551 for (auto& deviceInfo : provider->mDevices) {
2552 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
2553 if (res != NAME_NOT_FOUND) return res;
2554 }
2555 }
2556
2557 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002558}
2559
2560void CameraProviderManager::filterLogicalCameraIdsLocked(
2561 std::vector<std::string>& deviceIds) const
2562{
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002563 // Map between camera facing and camera IDs related to logical camera.
2564 std::map<int, std::unordered_set<std::string>> idCombos;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002565
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002566 // Collect all logical and its underlying physical camera IDs for each
2567 // facing.
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002568 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002569 auto deviceInfo = findDeviceInfoLocked(deviceId);
2570 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002571
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002572 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002573 continue;
2574 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002575
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002576 // combo contains the ids of a logical camera and its physical cameras
2577 std::vector<std::string> combo = deviceInfo->mPhysicalIds;
2578 combo.push_back(deviceId);
2579
2580 hardware::CameraInfo info;
2581 status_t res = deviceInfo->getCameraInfo(&info);
2582 if (res != OK) {
2583 ALOGE("%s: Error reading camera info: %s (%d)", __FUNCTION__, strerror(-res), res);
2584 continue;
2585 }
2586 idCombos[info.facing].insert(combo.begin(), combo.end());
2587 }
2588
2589 // Only expose one camera ID per facing for all logical and underlying
2590 // physical camera IDs.
2591 for (auto& r : idCombos) {
2592 auto& removedIds = r.second;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002593 for (auto& id : deviceIds) {
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002594 auto foundId = std::find(removedIds.begin(), removedIds.end(), id);
2595 if (foundId == removedIds.end()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002596 continue;
2597 }
2598
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002599 removedIds.erase(foundId);
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002600 break;
2601 }
Shuzhen Wang38e119b2018-10-01 16:03:53 -07002602 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
2603 [&removedIds](const std::string& s) {
2604 return removedIds.find(s) != removedIds.end();}),
2605 deviceIds.end());
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002606 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002607}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002608
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002609} // namespace android