blob: 137ffea66fee09903184b095555524c46a5ef95a [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>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080032#include <hidl/ServiceManagement.h>
Emilian Peev71c73a22017-03-21 16:35:51 +000033#include <functional>
34#include <camera_metadata_hidden.h>
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080035#include <android-base/parseint.h>
Peter Kalauskasa29c1352018-10-10 12:05:42 -070036#include <android-base/logging.h>
37#include <cutils/properties.h>
38#include <hwbinder/IPCThreadState.h>
39#include <utils/Trace.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080040
41namespace android {
42
43using namespace ::android::hardware::camera;
44using namespace ::android::hardware::camera::common::V1_0;
Peter Kalauskasa29c1352018-10-10 12:05:42 -070045using std::literals::chrono_literals::operator""s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080046
47namespace {
48// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
49// service manager
50const std::string kLegacyProviderName("legacy/0");
Yin-Chia Yehd78041a2018-01-20 13:45:38 -080051const std::string kExternalProviderName("external/0");
Peter Kalauskasa29c1352018-10-10 12:05:42 -070052const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));
53
54// The extra amount of time to hold a reference to an ICameraProvider after it is no longer needed.
55// Hold the reference for this extra time so that if the camera is unreferenced and then referenced
56// again quickly, we do not let the HAL exit and then need to immediately restart it. An example
57// when this could happen is switching from a front-facing to a rear-facing camera. If the HAL were
58// to exit during the camera switch, the camera could appear janky to the user.
59const std::chrono::system_clock::duration kCameraKeepAliveDelay = 3s;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080060
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080061} // anonymous namespace
62
Emilian Peev538c90e2018-12-17 18:03:19 +000063const float CameraProviderManager::kDepthARTolerance = .1f;
64
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080065CameraProviderManager::HardwareServiceInteractionProxy
66CameraProviderManager::sHardwareServiceInteractionProxy{};
67
68CameraProviderManager::~CameraProviderManager() {
69}
70
71status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
72 ServiceInteractionProxy* proxy) {
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080073 std::lock_guard<std::mutex> lock(mInterfaceMutex);
74 if (proxy == nullptr) {
75 ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
76 return BAD_VALUE;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080077 }
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080078 mListener = listener;
79 mServiceProxy = proxy;
Eino-Ville Talvala63f36112018-12-06 14:57:03 -080080 mDeviceState = static_cast<hardware::hidl_bitfield<provider::V2_5::DeviceState>>(
81 provider::V2_5::DeviceState::NORMAL);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080082
Yin-Chia Yeh4c5b1c72017-01-31 13:20:56 -080083 // Registering will trigger notifications for all already-known providers
84 bool success = mServiceProxy->registerForNotifications(
85 /* instance name, empty means no filter */ "",
86 this);
87 if (!success) {
88 ALOGE("%s: Unable to register with hardware service manager for notifications "
89 "about camera providers", __FUNCTION__);
90 return INVALID_OPERATION;
Yin-Chia Yeh65405092017-01-13 15:42:28 -080091 }
Emilian Peev5d7e5152017-02-22 15:37:48 +000092
Eino-Ville Talvala65665362017-02-24 13:07:56 -080093 // See if there's a passthrough HAL, but let's not complain if there's not
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -070094 addProviderLocked(kLegacyProviderName, /*expected*/ false);
Yin-Chia Yehd78041a2018-01-20 13:45:38 -080095 addProviderLocked(kExternalProviderName, /*expected*/ false);
Eino-Ville Talvala65665362017-02-24 13:07:56 -080096
Peter Kalauskasa29c1352018-10-10 12:05:42 -070097 IPCThreadState::self()->flushCommands();
98
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080099 return OK;
100}
101
102int CameraProviderManager::getCameraCount() const {
103 std::lock_guard<std::mutex> lock(mInterfaceMutex);
104 int count = 0;
105 for (auto& provider : mProviders) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800106 count += provider->mUniqueCameraIds.size();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800107 }
108 return count;
109}
110
111std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
112 std::lock_guard<std::mutex> lock(mInterfaceMutex);
113 std::vector<std::string> deviceIds;
114 for (auto& provider : mProviders) {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700115 for (auto& id : provider->mUniqueCameraIds) {
116 deviceIds.push_back(id);
117 }
118 }
119 return deviceIds;
120}
121
Emilian Peevf53f66e2017-04-11 14:29:43 +0100122std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700123 std::lock_guard<std::mutex> lock(mInterfaceMutex);
124 std::vector<std::string> deviceIds;
125 for (auto& provider : mProviders) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700126 std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
127
128 // API1 app doesn't handle logical and physical camera devices well. So
129 // for each [logical, physical1, physical2, ...] id combo, only take the
130 // first id advertised by HAL, and filter out the rest.
131 filterLogicalCameraIdsLocked(providerDeviceIds);
132
133 deviceIds.insert(deviceIds.end(), providerDeviceIds.begin(), providerDeviceIds.end());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800134 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800135
136 std::sort(deviceIds.begin(), deviceIds.end(),
137 [](const std::string& a, const std::string& b) -> bool {
138 uint32_t aUint = 0, bUint = 0;
139 bool aIsUint = base::ParseUint(a, &aUint);
140 bool bIsUint = base::ParseUint(b, &bUint);
141
142 // Uint device IDs first
143 if (aIsUint && bIsUint) {
144 return aUint < bUint;
145 } else if (aIsUint) {
146 return true;
147 } else if (bIsUint) {
148 return false;
149 }
150 // Simple string compare if both id are not uint
151 return a < b;
152 });
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800153 return deviceIds;
154}
155
156bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
157 std::lock_guard<std::mutex> lock(mInterfaceMutex);
158 return isValidDeviceLocked(id, majorVersion);
159}
160
161bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
162 for (auto& provider : mProviders) {
163 for (auto& deviceInfo : provider->mDevices) {
164 if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
165 return true;
166 }
167 }
168 }
169 return false;
170}
171
172bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
173 std::lock_guard<std::mutex> lock(mInterfaceMutex);
174
175 auto deviceInfo = findDeviceInfoLocked(id);
176 if (deviceInfo == nullptr) return false;
177
178 return deviceInfo->hasFlashUnit();
179}
180
181status_t CameraProviderManager::getResourceCost(const std::string &id,
182 CameraResourceCost* cost) const {
183 std::lock_guard<std::mutex> lock(mInterfaceMutex);
184
185 auto deviceInfo = findDeviceInfoLocked(id);
186 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
187
188 *cost = deviceInfo->mResourceCost;
189 return OK;
190}
191
192status_t CameraProviderManager::getCameraInfo(const std::string &id,
193 hardware::CameraInfo* info) const {
194 std::lock_guard<std::mutex> lock(mInterfaceMutex);
195
196 auto deviceInfo = findDeviceInfoLocked(id);
197 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
198
199 return deviceInfo->getCameraInfo(info);
200}
201
Emilian Peev35ae8262018-11-08 13:11:32 +0000202status_t CameraProviderManager::isSessionConfigurationSupported(const std::string& id,
203 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
204 bool *status /*out*/) const {
205 std::lock_guard<std::mutex> lock(mInterfaceMutex);
206
207 auto deviceInfo = findDeviceInfoLocked(id);
208 if (deviceInfo == nullptr) {
209 return NAME_NOT_FOUND;
210 }
211
212 return deviceInfo->isSessionConfigurationSupported(configuration, status);
213}
214
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800215status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
216 CameraMetadata* characteristics) const {
217 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700218 return getCameraCharacteristicsLocked(id, characteristics);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800219}
220
221status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
222 hardware::hidl_version *v) {
223 std::lock_guard<std::mutex> lock(mInterfaceMutex);
224
225 hardware::hidl_version maxVersion{0,0};
226 bool found = false;
227 for (auto& provider : mProviders) {
228 for (auto& deviceInfo : provider->mDevices) {
229 if (deviceInfo->mId == id) {
230 if (deviceInfo->mVersion > maxVersion) {
231 maxVersion = deviceInfo->mVersion;
232 found = true;
233 }
234 }
235 }
236 }
237 if (!found) {
238 return NAME_NOT_FOUND;
239 }
240 *v = maxVersion;
241 return OK;
242}
243
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700244bool CameraProviderManager::supportSetTorchMode(const std::string &id) const {
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700245 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700246 for (auto& provider : mProviders) {
247 auto deviceInfo = findDeviceInfoLocked(id);
248 if (deviceInfo != nullptr) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700249 return provider->mSetTorchModeSupported;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700250 }
251 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700252 return false;
Yin-Chia Yehdc3134e2017-03-23 15:26:59 -0700253}
254
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800255status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
256 std::lock_guard<std::mutex> lock(mInterfaceMutex);
257
258 auto deviceInfo = findDeviceInfoLocked(id);
259 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
260
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700261 // Pass the camera ID to start interface so that it will save it to the map of ICameraProviders
262 // that are currently in use.
263 const sp<provider::V2_4::ICameraProvider> interface =
264 deviceInfo->mParentProvider->startProviderInterface();
265 if (interface == nullptr) {
266 return DEAD_OBJECT;
267 }
268 saveRef(DeviceMode::TORCH, deviceInfo->mId, interface);
269
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800270 return deviceInfo->setTorchMode(enabled);
271}
272
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800273status_t CameraProviderManager::setUpVendorTags() {
Emilian Peev71c73a22017-03-21 16:35:51 +0000274 sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
275
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800276 for (auto& provider : mProviders) {
Peter Kalauskas1b3c9072018-11-07 12:41:53 -0800277 tagCache->addVendorDescriptor(provider->mProviderTagid, provider->mVendorTagDescriptor);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800278 }
Emilian Peev71c73a22017-03-21 16:35:51 +0000279
280 VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
281
Yin-Chia Yeh067428c2017-01-13 15:19:24 -0800282 return OK;
283}
284
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800285status_t CameraProviderManager::notifyDeviceStateChange(
286 hardware::hidl_bitfield<provider::V2_5::DeviceState> newState) {
287 std::lock_guard<std::mutex> lock(mInterfaceMutex);
288 mDeviceState = newState;
289 status_t res = OK;
290 for (auto& provider : mProviders) {
291 ALOGV("%s: Notifying %s for new state 0x%" PRIx64,
292 __FUNCTION__, provider->mProviderName.c_str(), newState);
293 status_t singleRes = provider->notifyDeviceStateChange(mDeviceState);
294 if (singleRes != OK) {
295 ALOGE("%s: Unable to notify provider %s about device state change",
296 __FUNCTION__,
297 provider->mProviderName.c_str());
298 res = singleRes;
299 // continue to do the rest of the providers instead of returning now
300 }
301 }
302 return res;
303}
304
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800305status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800306 const sp<device::V3_2::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800307 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800308 sp<device::V3_2::ICameraDeviceSession> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800309
310 std::lock_guard<std::mutex> lock(mInterfaceMutex);
311
312 auto deviceInfo = findDeviceInfoLocked(id,
313 /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
314 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
315
316 auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700317 const sp<provider::V2_4::ICameraProvider> provider =
318 deviceInfo->mParentProvider->startProviderInterface();
319 if (provider == nullptr) {
320 return DEAD_OBJECT;
321 }
322 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800323
324 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700325 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700326 auto interface = deviceInfo3->startDeviceInterface<
327 CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
328 if (interface == nullptr) {
329 return DEAD_OBJECT;
330 }
331
332 ret = interface->open(callback, [&status, &session]
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800333 (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
334 status = s;
335 if (status == Status::OK) {
336 *session = cameraSession;
337 }
338 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700339 if (!ret.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700340 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700341 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
342 __FUNCTION__, id.c_str(), ret.description().c_str());
343 return DEAD_OBJECT;
344 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800345 return mapToStatusT(status);
346}
347
348status_t CameraProviderManager::openSession(const std::string &id,
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800349 const sp<device::V1_0::ICameraDeviceCallback>& callback,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800350 /*out*/
Peter Kalauskasb7bd4382018-11-15 17:19:48 -0800351 sp<device::V1_0::ICameraDevice> *session) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800352
353 std::lock_guard<std::mutex> lock(mInterfaceMutex);
354
355 auto deviceInfo = findDeviceInfoLocked(id,
356 /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
357 if (deviceInfo == nullptr) return NAME_NOT_FOUND;
358
359 auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700360 const sp<provider::V2_4::ICameraProvider> provider =
361 deviceInfo->mParentProvider->startProviderInterface();
362 if (provider == nullptr) {
363 return DEAD_OBJECT;
364 }
365 saveRef(DeviceMode::CAMERA, id, provider);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800366
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700367 auto interface = deviceInfo1->startDeviceInterface<
368 CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT>();
369 if (interface == nullptr) {
370 return DEAD_OBJECT;
371 }
372 hardware::Return<Status> status = interface->open(callback);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700373 if (!status.isOk()) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700374 removeRef(DeviceMode::CAMERA, id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700375 ALOGE("%s: Transaction error opening a session for camera device %s: %s",
376 __FUNCTION__, id.c_str(), status.description().c_str());
377 return DEAD_OBJECT;
378 }
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800379 if (status == Status::OK) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700380 *session = interface;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800381 }
382 return mapToStatusT(status);
383}
384
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700385void CameraProviderManager::saveRef(DeviceMode usageType, const std::string &cameraId,
386 sp<provider::V2_4::ICameraProvider> provider) {
387 if (!kEnableLazyHal) {
388 return;
389 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800390 ALOGV("Saving camera provider %s for camera device %s", provider->descriptor, cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700391 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
392 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *primaryMap, *alternateMap;
393 if (usageType == DeviceMode::TORCH) {
394 primaryMap = &mTorchProviderByCameraId;
395 alternateMap = &mCameraProviderByCameraId;
396 } else {
397 primaryMap = &mCameraProviderByCameraId;
398 alternateMap = &mTorchProviderByCameraId;
399 }
400 auto id = cameraId.c_str();
401 (*primaryMap)[id] = provider;
402 auto search = alternateMap->find(id);
403 if (search != alternateMap->end()) {
404 ALOGW("%s: Camera device %s is using both torch mode and camera mode simultaneously. "
405 "That should not be possible", __FUNCTION__, id);
406 }
407 ALOGV("%s: Camera device %s connected", __FUNCTION__, id);
408}
409
410void CameraProviderManager::removeRef(DeviceMode usageType, const std::string &cameraId) {
411 if (!kEnableLazyHal) {
412 return;
413 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800414 ALOGV("Removing camera device %s", cameraId.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700415 std::unordered_map<std::string, sp<provider::V2_4::ICameraProvider>> *providerMap;
416 if (usageType == DeviceMode::TORCH) {
417 providerMap = &mTorchProviderByCameraId;
418 } else {
419 providerMap = &mCameraProviderByCameraId;
420 }
421 std::lock_guard<std::mutex> lock(mProviderInterfaceMapLock);
422 auto search = providerMap->find(cameraId.c_str());
423 if (search != providerMap->end()) {
424 auto ptr = search->second;
425 auto future = std::async(std::launch::async, [ptr] {
426 std::this_thread::sleep_for(kCameraKeepAliveDelay);
427 IPCThreadState::self()->flushCommands();
428 });
429 providerMap->erase(cameraId.c_str());
430 } else {
431 ALOGE("%s: Asked to remove reference for camera %s, but no reference to it was found. This "
432 "could mean removeRef was called twice for the same camera ID.", __FUNCTION__,
433 cameraId.c_str());
434 }
435}
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800436
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800437hardware::Return<void> CameraProviderManager::onRegistration(
438 const hardware::hidl_string& /*fqName*/,
439 const hardware::hidl_string& name,
440 bool /*preexisting*/) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700441 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Emilian Peevaee727d2017-05-04 16:35:48 +0100442 {
443 std::lock_guard<std::mutex> lock(mInterfaceMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800444
Emilian Peevaee727d2017-05-04 16:35:48 +0100445 addProviderLocked(name);
446 }
447
448 sp<StatusListener> listener = getStatusListener();
449 if (nullptr != listener.get()) {
450 listener->onNewProviderRegistered();
451 }
452
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700453 IPCThreadState::self()->flushCommands();
454
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800455 return hardware::Return<void>();
456}
457
458status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
459 std::lock_guard<std::mutex> lock(mInterfaceMutex);
460
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800461 for (auto& provider : mProviders) {
462 provider->dump(fd, args);
463 }
464 return OK;
465}
466
467CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800468 const std::string& id,
469 hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800470 for (auto& provider : mProviders) {
471 for (auto& deviceInfo : provider->mDevices) {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800472 if (deviceInfo->mId == id &&
473 minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800474 return deviceInfo.get();
475 }
476 }
477 }
478 return nullptr;
479}
480
Emilian Peev71c73a22017-03-21 16:35:51 +0000481metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
482 const std::string& id, hardware::hidl_version minVersion,
483 hardware::hidl_version maxVersion) const {
484 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
485
486 std::lock_guard<std::mutex> lock(mInterfaceMutex);
487 for (auto& provider : mProviders) {
488 for (auto& deviceInfo : provider->mDevices) {
489 if (deviceInfo->mId == id &&
490 minVersion <= deviceInfo->mVersion &&
491 maxVersion >= deviceInfo->mVersion) {
492 return provider->mProviderTagid;
493 }
494 }
495 }
496
497 return ret;
498}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800499
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700500void CameraProviderManager::ProviderInfo::DeviceInfo3::queryPhysicalCameraIds() {
501 camera_metadata_entry_t entryCap;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700502
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700503 entryCap = mCameraCharacteristics.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700504 for (size_t i = 0; i < entryCap.count; ++i) {
505 uint8_t capability = entryCap.data.u8[i];
506 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700507 mIsLogicalCamera = true;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700508 break;
509 }
510 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700511 if (!mIsLogicalCamera) {
512 return;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700513 }
514
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700515 camera_metadata_entry_t entryIds = mCameraCharacteristics.find(
516 ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700517 const uint8_t* ids = entryIds.data.u8;
518 size_t start = 0;
519 for (size_t i = 0; i < entryIds.count; ++i) {
520 if (ids[i] == '\0') {
521 if (start != i) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700522 mPhysicalIds.push_back((const char*)ids+start);
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700523 }
524 start = i+1;
525 }
526 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700527}
528
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000529void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedSizes(
530 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
531 std::vector<std::tuple<size_t, size_t>> *sizes/*out*/) {
532 if (sizes == nullptr) {
533 return;
534 }
535
536 auto scalerDims = ch.find(tag);
537 if (scalerDims.count > 0) {
538 // Scaler entry contains 4 elements (format, width, height, type)
539 for (size_t i = 0; i < scalerDims.count; i += 4) {
540 if ((scalerDims.data.i32[i] == format) &&
541 (scalerDims.data.i32[i+3] ==
542 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
543 sizes->push_back(std::make_tuple(scalerDims.data.i32[i+1],
544 scalerDims.data.i32[i+2]));
545 }
546 }
547 }
548}
549
550void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDurations(
551 const CameraMetadata& ch, uint32_t tag, android_pixel_format_t format,
552 const std::vector<std::tuple<size_t, size_t>>& sizes,
553 std::vector<int64_t> *durations/*out*/) {
554 if (durations == nullptr) {
555 return;
556 }
557
558 auto availableDurations = ch.find(tag);
559 if (availableDurations.count > 0) {
560 // Duration entry contains 4 elements (format, width, height, duration)
561 for (size_t i = 0; i < availableDurations.count; i += 4) {
562 for (const auto& size : sizes) {
563 int64_t width = std::get<0>(size);
564 int64_t height = std::get<1>(size);
565 if ((availableDurations.data.i64[i] == format) &&
566 (availableDurations.data.i64[i+1] == width) &&
567 (availableDurations.data.i64[i+2] == height)) {
568 durations->push_back(availableDurations.data.i64[i+3]);
569 }
570 }
571 }
572 }
573}
574void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthDurations(
575 const std::vector<int64_t>& depthDurations, const std::vector<int64_t>& blobDurations,
576 std::vector<int64_t> *dynamicDepthDurations /*out*/) {
577 if ((dynamicDepthDurations == nullptr) || (depthDurations.size() != blobDurations.size())) {
578 return;
579 }
580
581 // Unfortunately there is no direct way to calculate the dynamic depth stream duration.
582 // Processing time on camera service side can vary greatly depending on multiple
583 // variables which are not under our control. Make a guesstimate by taking the maximum
584 // corresponding duration value from depth and blob.
585 auto depthDuration = depthDurations.begin();
586 auto blobDuration = blobDurations.begin();
587 dynamicDepthDurations->reserve(depthDurations.size());
588 while ((depthDuration != depthDurations.end()) && (blobDuration != blobDurations.end())) {
589 dynamicDepthDurations->push_back(std::max(*depthDuration, *blobDuration));
590 depthDuration++; blobDuration++;
591 }
592}
593
594void CameraProviderManager::ProviderInfo::DeviceInfo3::getSupportedDynamicDepthSizes(
595 const std::vector<std::tuple<size_t, size_t>>& blobSizes,
596 const std::vector<std::tuple<size_t, size_t>>& depthSizes,
597 std::vector<std::tuple<size_t, size_t>> *dynamicDepthSizes /*out*/,
598 std::vector<std::tuple<size_t, size_t>> *internalDepthSizes /*out*/) {
599 if (dynamicDepthSizes == nullptr || internalDepthSizes == nullptr) {
600 return;
601 }
602
603 // The dynamic depth spec. does not mention how close the AR ratio should be.
604 // Try using something appropriate.
Emilian Peev538c90e2018-12-17 18:03:19 +0000605 float ARTolerance = kDepthARTolerance;
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000606
607 for (const auto& blobSize : blobSizes) {
608 float jpegAR = static_cast<float> (std::get<0>(blobSize)) /
609 static_cast<float>(std::get<1>(blobSize));
610 bool found = false;
611 for (const auto& depthSize : depthSizes) {
612 if (depthSize == blobSize) {
613 internalDepthSizes->push_back(depthSize);
614 found = true;
615 break;
616 } else {
617 float depthAR = static_cast<float> (std::get<0>(depthSize)) /
618 static_cast<float>(std::get<1>(depthSize));
619 if (std::fabs(jpegAR - depthAR) <= ARTolerance) {
620 internalDepthSizes->push_back(depthSize);
621 found = true;
622 break;
623 }
624 }
625 }
626
627 if (found) {
628 dynamicDepthSizes->push_back(blobSize);
629 }
630 }
631}
632
Emilian Peevcbf174b2019-01-25 14:38:59 -0800633bool CameraProviderManager::ProviderInfo::DeviceInfo3::isDepthPhotoLibraryPresent() {
634 static bool libraryPresent = false;
635 static bool initialized = false;
636 if (initialized) {
637 return libraryPresent;
638 } else {
639 initialized = true;
640 }
641
642 void* depthLibHandle = dlopen(camera3::kDepthPhotoLibrary, RTLD_NOW | RTLD_LOCAL);
643 if (depthLibHandle == nullptr) {
644 return false;
645 }
646
647 auto processFunc = dlsym(depthLibHandle, camera3::kDepthPhotoProcessFunction);
648 if (processFunc != nullptr) {
649 libraryPresent = true;
650 } else {
651 libraryPresent = false;
652 }
653 dlclose(depthLibHandle);
654
655 return libraryPresent;
656}
657
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000658status_t CameraProviderManager::ProviderInfo::DeviceInfo3::addDynamicDepthTags() {
659 uint32_t depthExclTag = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE;
660 uint32_t depthSizesTag = ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS;
661 auto& c = mCameraCharacteristics;
662 std::vector<std::tuple<size_t, size_t>> supportedBlobSizes, supportedDepthSizes,
663 supportedDynamicDepthSizes, internalDepthSizes;
664 auto chTags = c.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
665 if (chTags.count == 0) {
666 ALOGE("%s: Supported camera characteristics is empty!", __FUNCTION__);
667 return BAD_VALUE;
668 }
669
670 bool isDepthExclusivePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
671 depthExclTag) != (chTags.data.i32 + chTags.count);
672 bool isDepthSizePresent = std::find(chTags.data.i32, chTags.data.i32 + chTags.count,
673 depthExclTag) != (chTags.data.i32 + chTags.count);
674 if (!(isDepthExclusivePresent && isDepthSizePresent)) {
675 // No depth support, nothing more to do.
676 return OK;
677 }
678
679 auto depthExclusiveEntry = c.find(depthExclTag);
680 if (depthExclusiveEntry.count > 0) {
681 if (depthExclusiveEntry.data.u8[0] != ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE) {
682 // Depth support is exclusive, nothing more to do.
683 return OK;
684 }
685 } else {
686 ALOGE("%s: Advertised depth exclusive tag but value is not present!", __FUNCTION__);
687 return BAD_VALUE;
688 }
689
690 getSupportedSizes(c, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, HAL_PIXEL_FORMAT_BLOB,
691 &supportedBlobSizes);
692 getSupportedSizes(c, depthSizesTag, HAL_PIXEL_FORMAT_Y16, &supportedDepthSizes);
693 if (supportedBlobSizes.empty() || supportedDepthSizes.empty()) {
694 // Nothing to do in this case.
695 return OK;
696 }
697
698 getSupportedDynamicDepthSizes(supportedBlobSizes, supportedDepthSizes,
699 &supportedDynamicDepthSizes, &internalDepthSizes);
700 if (supportedDynamicDepthSizes.empty()) {
701 ALOGE("%s: No dynamic depth size matched!", __func__);
702 // Nothing more to do.
703 return OK;
704 }
705
Emilian Peevcbf174b2019-01-25 14:38:59 -0800706 if(!isDepthPhotoLibraryPresent()) {
707 // Depth photo processing library is not present, nothing more to do.
708 return OK;
709 }
710
Emilian Peev4c6d2b52019-01-04 17:13:56 +0000711 std::vector<int32_t> dynamicDepthEntries;
712 for (const auto& it : supportedDynamicDepthSizes) {
713 int32_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(it)),
714 static_cast<int32_t> (std::get<1>(it)),
715 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT };
716 dynamicDepthEntries.insert(dynamicDepthEntries.end(), entry, entry + 4);
717 }
718
719 std::vector<int64_t> depthMinDurations, depthStallDurations;
720 std::vector<int64_t> blobMinDurations, blobStallDurations;
721 std::vector<int64_t> dynamicDepthMinDurations, dynamicDepthStallDurations;
722
723 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS,
724 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthMinDurations);
725 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
726 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobMinDurations);
727 if (blobMinDurations.empty() || depthMinDurations.empty() ||
728 (depthMinDurations.size() != blobMinDurations.size())) {
729 ALOGE("%s: Unexpected number of available depth min durations! %zu vs. %zu",
730 __FUNCTION__, depthMinDurations.size(), blobMinDurations.size());
731 return BAD_VALUE;
732 }
733
734 getSupportedDurations(c, ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS,
735 HAL_PIXEL_FORMAT_Y16, internalDepthSizes, &depthStallDurations);
736 getSupportedDurations(c, ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
737 HAL_PIXEL_FORMAT_BLOB, supportedDynamicDepthSizes, &blobStallDurations);
738 if (blobStallDurations.empty() || depthStallDurations.empty() ||
739 (depthStallDurations.size() != blobStallDurations.size())) {
740 ALOGE("%s: Unexpected number of available depth stall durations! %zu vs. %zu",
741 __FUNCTION__, depthStallDurations.size(), blobStallDurations.size());
742 return BAD_VALUE;
743 }
744
745 getSupportedDynamicDepthDurations(depthMinDurations, blobMinDurations,
746 &dynamicDepthMinDurations);
747 getSupportedDynamicDepthDurations(depthStallDurations, blobStallDurations,
748 &dynamicDepthStallDurations);
749 if (dynamicDepthMinDurations.empty() || dynamicDepthStallDurations.empty() ||
750 (dynamicDepthMinDurations.size() != dynamicDepthStallDurations.size())) {
751 ALOGE("%s: Unexpected number of dynamic depth stall/min durations! %zu vs. %zu",
752 __FUNCTION__, dynamicDepthMinDurations.size(), dynamicDepthStallDurations.size());
753 return BAD_VALUE;
754 }
755
756 std::vector<int64_t> dynamicDepthMinDurationEntries;
757 auto itDuration = dynamicDepthMinDurations.begin();
758 auto itSize = supportedDynamicDepthSizes.begin();
759 while (itDuration != dynamicDepthMinDurations.end()) {
760 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
761 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
762 dynamicDepthMinDurationEntries.insert(dynamicDepthMinDurationEntries.end(), entry,
763 entry + 4);
764 itDuration++; itSize++;
765 }
766
767 std::vector<int64_t> dynamicDepthStallDurationEntries;
768 itDuration = dynamicDepthStallDurations.begin();
769 itSize = supportedDynamicDepthSizes.begin();
770 while (itDuration != dynamicDepthStallDurations.end()) {
771 int64_t entry[4] = {HAL_PIXEL_FORMAT_BLOB, static_cast<int32_t> (std::get<0>(*itSize)),
772 static_cast<int32_t> (std::get<1>(*itSize)), *itDuration};
773 dynamicDepthStallDurationEntries.insert(dynamicDepthStallDurationEntries.end(), entry,
774 entry + 4);
775 itDuration++; itSize++;
776 }
777
778 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
779 dynamicDepthEntries.data(), dynamicDepthEntries.size());
780 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS,
781 dynamicDepthMinDurationEntries.data(), dynamicDepthMinDurationEntries.size());
782 c.update(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS,
783 dynamicDepthStallDurationEntries.data(), dynamicDepthStallDurationEntries.size());
784
785 std::vector<int32_t> supportedChTags;
786 supportedChTags.reserve(chTags.count + 3);
787 supportedChTags.insert(supportedChTags.end(), chTags.data.i32,
788 chTags.data.i32 + chTags.count);
789 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
790 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS);
791 supportedChTags.push_back(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS);
792 c.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, supportedChTags.data(),
793 supportedChTags.size());
794
795 return OK;
796}
797
Shuzhen Wang268a1362018-10-16 16:32:59 -0700798status_t CameraProviderManager::ProviderInfo::DeviceInfo3::fixupMonochromeTags() {
799 status_t res = OK;
800 auto& c = mCameraCharacteristics;
801
802 // Override static metadata for MONOCHROME camera with older device version
803 if (mVersion.get_major() == 3 && mVersion.get_minor() < 5) {
804 camera_metadata_entry cap = c.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
805 for (size_t i = 0; i < cap.count; i++) {
806 if (cap.data.u8[i] == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
807 // ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
808 uint8_t cfa = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_MONO;
809 res = c.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &cfa, 1);
810 if (res != OK) {
811 ALOGE("%s: Failed to update COLOR_FILTER_ARRANGEMENT: %s (%d)",
812 __FUNCTION__, strerror(-res), res);
813 return res;
814 }
815
816 // ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
817 const std::vector<uint32_t> sKeys = {
818 ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
819 ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
820 ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
821 ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
822 ANDROID_SENSOR_COLOR_TRANSFORM1,
823 ANDROID_SENSOR_COLOR_TRANSFORM2,
824 ANDROID_SENSOR_FORWARD_MATRIX1,
825 ANDROID_SENSOR_FORWARD_MATRIX2,
826 };
827 res = removeAvailableKeys(c, sKeys,
828 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
829 if (res != OK) {
830 ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
831 __FUNCTION__, strerror(-res), res);
832 return res;
833 }
834
835 // ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS
836 const std::vector<uint32_t> reqKeys = {
837 ANDROID_COLOR_CORRECTION_MODE,
838 ANDROID_COLOR_CORRECTION_TRANSFORM,
839 ANDROID_COLOR_CORRECTION_GAINS,
840 };
841 res = removeAvailableKeys(c, reqKeys, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
842 if (res != OK) {
843 ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
844 __FUNCTION__, strerror(-res), res);
845 return res;
846 }
847
848 // ANDROID_REQUEST_AVAILABLE_RESULT_KEYS
849 const std::vector<uint32_t> resKeys = {
850 ANDROID_SENSOR_GREEN_SPLIT,
851 ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
852 ANDROID_COLOR_CORRECTION_MODE,
853 ANDROID_COLOR_CORRECTION_TRANSFORM,
854 ANDROID_COLOR_CORRECTION_GAINS,
855 };
856 res = removeAvailableKeys(c, resKeys, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
857 if (res != OK) {
858 ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
859 __FUNCTION__, strerror(-res), res);
860 return res;
861 }
862
863 // ANDROID_SENSOR_BLACK_LEVEL_PATTERN
864 camera_metadata_entry blEntry = c.find(ANDROID_SENSOR_BLACK_LEVEL_PATTERN);
865 for (size_t j = 1; j < blEntry.count; j++) {
866 blEntry.data.i32[j] = blEntry.data.i32[0];
867 }
868 }
869 }
870 }
871 return res;
872}
873
874status_t CameraProviderManager::ProviderInfo::DeviceInfo3::removeAvailableKeys(
875 CameraMetadata& c, const std::vector<uint32_t>& keys, uint32_t keyTag) {
876 status_t res = OK;
877
878 camera_metadata_entry keysEntry = c.find(keyTag);
879 if (keysEntry.count == 0) {
880 ALOGE("%s: Failed to find tag %u: %s (%d)", __FUNCTION__, keyTag, strerror(-res), res);
881 return res;
882 }
883 std::vector<int32_t> vKeys;
884 vKeys.reserve(keysEntry.count);
885 for (size_t i = 0; i < keysEntry.count; i++) {
886 if (std::find(keys.begin(), keys.end(), keysEntry.data.i32[i]) == keys.end()) {
887 vKeys.push_back(keysEntry.data.i32[i]);
888 }
889 }
890 res = c.update(keyTag, vKeys.data(), vKeys.size());
891 return res;
892}
893
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700894bool CameraProviderManager::isLogicalCamera(const std::string& id,
895 std::vector<std::string>* physicalCameraIds) {
896 std::lock_guard<std::mutex> lock(mInterfaceMutex);
897
898 auto deviceInfo = findDeviceInfoLocked(id);
899 if (deviceInfo == nullptr) return false;
900
901 if (deviceInfo->mIsLogicalCamera && physicalCameraIds != nullptr) {
902 *physicalCameraIds = deviceInfo->mPhysicalIds;
903 }
904 return deviceInfo->mIsLogicalCamera;
Shuzhen Wange8aceb52018-05-21 12:00:56 -0700905}
906
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700907bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) {
908 for (auto& provider : mProviders) {
909 for (auto& deviceInfo : provider->mDevices) {
910 if (deviceInfo->mId == cameraId) {
911 // cameraId is found in public camera IDs advertised by the
912 // provider.
913 return false;
914 }
915 }
916 }
917
918 for (auto& provider : mProviders) {
919 for (auto& deviceInfo : provider->mDevices) {
920 CameraMetadata info;
921 status_t res = deviceInfo->getCameraCharacteristics(&info);
922 if (res != OK) {
923 ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
924 deviceInfo->mId.c_str());
925 return false;
926 }
927
928 std::vector<std::string> physicalIds;
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700929 if (deviceInfo->mIsLogicalCamera) {
930 if (std::find(deviceInfo->mPhysicalIds.begin(), deviceInfo->mPhysicalIds.end(),
931 cameraId) != deviceInfo->mPhysicalIds.end()) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700932 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
933 deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
934 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
935 ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
936 __FUNCTION__, deviceVersion, cameraId.c_str());
937 return false;
938 } else {
939 return true;
940 }
941 }
942 }
943 }
944 }
945
946 return false;
947}
948
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700949status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800950 for (const auto& providerInfo : mProviders) {
951 if (providerInfo->mProviderName == newProvider) {
952 ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
953 newProvider.c_str());
954 return ALREADY_EXISTS;
955 }
956 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700957
958 sp<provider::V2_4::ICameraProvider> interface;
959 interface = mServiceProxy->getService(newProvider);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800960
961 if (interface == nullptr) {
962 if (expected) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700963 ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
964 newProvider.c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800965 return BAD_VALUE;
966 } else {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800967 return OK;
968 }
969 }
970
Peter Kalauskasa29c1352018-10-10 12:05:42 -0700971 sp<ProviderInfo> providerInfo = new ProviderInfo(newProvider, this);
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800972 status_t res = providerInfo->initialize(interface, mDeviceState);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800973 if (res != OK) {
974 return res;
975 }
976
977 mProviders.push_back(providerInfo);
978
979 return OK;
980}
981
982status_t CameraProviderManager::removeProvider(const std::string& provider) {
Shuzhen Wang6ba8eb22018-07-08 13:10:44 -0700983 std::lock_guard<std::mutex> providerLock(mProviderLifecycleLock);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700984 std::unique_lock<std::mutex> lock(mInterfaceMutex);
985 std::vector<String8> removedDeviceIds;
986 status_t res = NAME_NOT_FOUND;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800987 for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
988 if ((*it)->mProviderName == provider) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700989 removedDeviceIds.reserve((*it)->mDevices.size());
990 for (auto& deviceInfo : (*it)->mDevices) {
991 removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
992 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800993 mProviders.erase(it);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700994 res = OK;
995 break;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800996 }
997 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700998 if (res != OK) {
999 ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
1000 provider.c_str());
1001 } else {
1002 // Inform camera service of loss of presence for all the devices from this provider,
1003 // without lock held for reentrancy
1004 sp<StatusListener> listener = getStatusListener();
1005 if (listener != nullptr) {
1006 lock.unlock();
1007 for (auto& id : removedDeviceIds) {
1008 listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
1009 }
1010 }
1011 }
1012 return res;
1013}
1014
1015sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
1016 return mListener.promote();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001017}
1018
1019/**** Methods for ProviderInfo ****/
1020
1021
1022CameraProviderManager::ProviderInfo::ProviderInfo(
1023 const std::string &providerName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001024 CameraProviderManager *manager) :
1025 mProviderName(providerName),
Emilian Peev71c73a22017-03-21 16:35:51 +00001026 mProviderTagid(generateVendorTagId(providerName)),
Emilian Peevcdb74a62017-05-11 20:29:52 +01001027 mUniqueDeviceCount(0),
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001028 mManager(manager) {
1029 (void) mManager;
1030}
1031
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001032status_t CameraProviderManager::ProviderInfo::initialize(
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001033 sp<provider::V2_4::ICameraProvider>& interface,
1034 hardware::hidl_bitfield<provider::V2_5::DeviceState> currentDeviceState) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001035 status_t res = parseProviderName(mProviderName, &mType, &mId);
1036 if (res != OK) {
1037 ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
1038 return BAD_VALUE;
1039 }
Yin-Chia Yeh65405092017-01-13 15:42:28 -08001040 ALOGI("Connecting to new camera provider: %s, isRemote? %d",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001041 mProviderName.c_str(), interface->isRemote());
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001042
1043 // Determine minor version
1044 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1045 if (castResult.isOk()) {
1046 mMinorVersion = 5;
1047 } else {
1048 mMinorVersion = 4;
1049 }
1050
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001051 // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
1052 // before setCallback returns
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001053 hardware::Return<Status> status = interface->setCallback(this);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001054 if (!status.isOk()) {
1055 ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
1056 __FUNCTION__, mProviderName.c_str(), status.description().c_str());
1057 return DEAD_OBJECT;
1058 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001059 if (status != Status::OK) {
1060 ALOGE("%s: Unable to register callbacks with camera provider '%s'",
1061 __FUNCTION__, mProviderName.c_str());
1062 return mapToStatusT(status);
1063 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001064
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001065 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001066 if (!linked.isOk()) {
1067 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1068 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1069 return DEAD_OBJECT;
1070 } else if (!linked) {
1071 ALOGW("%s: Unable to link to provider '%s' death notifications",
1072 __FUNCTION__, mProviderName.c_str());
1073 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001074
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001075 if (!kEnableLazyHal) {
1076 // Save HAL reference indefinitely
1077 mSavedInterface = interface;
1078 } else {
1079 mActiveInterface = interface;
1080 }
1081
1082 ALOGV("%s: Setting device state for %s: 0x%" PRIx64,
1083 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1084 notifyDeviceStateChange(currentDeviceState);
1085
1086 res = setUpVendorTags();
1087 if (res != OK) {
1088 ALOGE("%s: Unable to set up vendor tags from provider '%s'",
1089 __FUNCTION__, mProviderName.c_str());
1090 return res;
1091 }
1092
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001093 // Get initial list of camera devices, if any
1094 std::vector<std::string> devices;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001095 hardware::Return<void> ret = interface->getCameraIdList([&status, this, &devices](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001096 Status idStatus,
1097 const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
1098 status = idStatus;
1099 if (status == Status::OK) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001100 for (auto& name : cameraDeviceNames) {
1101 uint16_t major, minor;
1102 std::string type, id;
1103 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1104 if (res != OK) {
1105 ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
1106 status = Status::INTERNAL_ERROR;
1107 } else {
1108 devices.push_back(name);
1109 mProviderPublicCameraIds.push_back(id);
1110 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001111 }
1112 } });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001113 if (!ret.isOk()) {
1114 ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
1115 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1116 return DEAD_OBJECT;
1117 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001118 if (status != Status::OK) {
1119 ALOGE("%s: Unable to query for camera devices from provider '%s'",
1120 __FUNCTION__, mProviderName.c_str());
1121 return mapToStatusT(status);
1122 }
1123
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001124 ret = interface->isSetTorchModeSupported(
1125 [this](auto status, bool supported) {
1126 if (status == Status::OK) {
1127 mSetTorchModeSupported = supported;
1128 }
1129 });
1130 if (!ret.isOk()) {
1131 ALOGE("%s: Transaction error checking torch mode support '%s': %s",
1132 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1133 return DEAD_OBJECT;
1134 }
1135
1136 mIsRemote = interface->isRemote();
1137
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001138 sp<StatusListener> listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001139 for (auto& device : devices) {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001140 std::string id;
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001141 status_t res = addDevice(device, common::V1_0::CameraDeviceStatus::PRESENT, &id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001142 if (res != OK) {
1143 ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
1144 __FUNCTION__, device.c_str(), strerror(-res), res);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001145 continue;
1146 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001147 }
1148
1149 ALOGI("Camera provider %s ready with %zu camera devices",
1150 mProviderName.c_str(), mDevices.size());
1151
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001152 mInitialized = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001153 return OK;
1154}
1155
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001156const sp<provider::V2_4::ICameraProvider>
1157CameraProviderManager::ProviderInfo::startProviderInterface() {
1158 ATRACE_CALL();
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001159 ALOGV("Request to start camera provider: %s", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001160 if (mSavedInterface != nullptr) {
1161 return mSavedInterface;
1162 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001163 if (!kEnableLazyHal) {
1164 ALOGE("Bad provider state! Should not be here on a non-lazy HAL!");
1165 return nullptr;
1166 }
1167
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001168 auto interface = mActiveInterface.promote();
1169 if (interface == nullptr) {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001170 ALOGI("Camera HAL provider needs restart, calling getService(%s)", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001171 interface = mManager->mServiceProxy->getService(mProviderName);
1172 interface->setCallback(this);
1173 hardware::Return<bool> linked = interface->linkToDeath(this, /*cookie*/ mId);
1174 if (!linked.isOk()) {
1175 ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
1176 __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
1177 mManager->removeProvider(mProviderName);
1178 return nullptr;
1179 } else if (!linked) {
1180 ALOGW("%s: Unable to link to provider '%s' death notifications",
1181 __FUNCTION__, mProviderName.c_str());
1182 }
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001183 // Send current device state
1184 if (mMinorVersion >= 5) {
1185 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1186 if (castResult.isOk()) {
1187 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1188 if (interface_2_5 != nullptr) {
1189 ALOGV("%s: Initial device state for %s: 0x %" PRIx64,
1190 __FUNCTION__, mProviderName.c_str(), mDeviceState);
1191 interface_2_5->notifyDeviceStateChange(mDeviceState);
1192 }
1193 }
1194 }
1195
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001196 mActiveInterface = interface;
1197 } else {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001198 ALOGV("Camera provider (%s) already in use. Re-using instance.", mProviderName.c_str());
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001199 }
1200 return interface;
1201}
1202
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001203const std::string& CameraProviderManager::ProviderInfo::getType() const {
1204 return mType;
1205}
1206
1207status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
1208 CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
1209
1210 ALOGI("Enumerating new camera device: %s", name.c_str());
1211
1212 uint16_t major, minor;
1213 std::string type, id;
1214
1215 status_t res = parseDeviceName(name, &major, &minor, &type, &id);
1216 if (res != OK) {
1217 return res;
1218 }
1219 if (type != mType) {
1220 ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
1221 type.c_str(), mType.c_str());
1222 return BAD_VALUE;
1223 }
1224 if (mManager->isValidDeviceLocked(id, major)) {
1225 ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
1226 name.c_str(), id.c_str(), major);
1227 return BAD_VALUE;
1228 }
1229
1230 std::unique_ptr<DeviceInfo> deviceInfo;
1231 switch (major) {
1232 case 1:
Emilian Peev71c73a22017-03-21 16:35:51 +00001233 deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
1234 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001235 break;
1236 case 3:
Emilian Peev71c73a22017-03-21 16:35:51 +00001237 deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
1238 id, minor);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001239 break;
1240 default:
1241 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1242 name.c_str(), major);
1243 return BAD_VALUE;
1244 }
1245 if (deviceInfo == nullptr) return BAD_VALUE;
1246 deviceInfo->mStatus = initialStatus;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001247 bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001248
1249 mDevices.push_back(std::move(deviceInfo));
1250
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001251 mUniqueCameraIds.insert(id);
1252 if (isAPI1Compatible) {
Shuzhen Wang975a39e2018-06-27 14:35:46 -07001253 // addDevice can be called more than once for the same camera id if HAL
1254 // supports openLegacy.
1255 if (std::find(mUniqueAPI1CompatibleCameraIds.begin(), mUniqueAPI1CompatibleCameraIds.end(),
1256 id) == mUniqueAPI1CompatibleCameraIds.end()) {
1257 mUniqueAPI1CompatibleCameraIds.push_back(id);
1258 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001259 }
1260
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001261 if (parsedId != nullptr) {
1262 *parsedId = id;
1263 }
1264 return OK;
1265}
1266
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001267void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
1268 for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
1269 if ((*it)->mId == id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001270 mUniqueCameraIds.erase(id);
1271 if ((*it)->isAPI1Compatible()) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07001272 mUniqueAPI1CompatibleCameraIds.erase(std::remove(
1273 mUniqueAPI1CompatibleCameraIds.begin(),
1274 mUniqueAPI1CompatibleCameraIds.end(), id));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001275 }
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001276 mDevices.erase(it);
1277 break;
1278 }
1279 }
1280}
1281
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001282status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001283 dprintf(fd, "== Camera Provider HAL %s (v2.%d, %s) static info: %zu devices: ==\n",
1284 mProviderName.c_str(),
1285 mMinorVersion,
1286 mIsRemote ? "remote" : "passthrough",
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001287 mDevices.size());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001288
1289 for (auto& device : mDevices) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001290 dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
1291 device->mVersion.get_major(), device->mVersion.get_minor());
1292 dprintf(fd, " Resource cost: %d\n", device->mResourceCost.resourceCost);
1293 if (device->mResourceCost.conflictingDevices.size() == 0) {
1294 dprintf(fd, " Conflicting devices: None\n");
1295 } else {
1296 dprintf(fd, " Conflicting devices:\n");
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001297 for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001298 dprintf(fd, " %s\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001299 device->mResourceCost.conflictingDevices[i].c_str());
1300 }
1301 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001302 dprintf(fd, " API1 info:\n");
1303 dprintf(fd, " Has a flash unit: %s\n",
1304 device->hasFlashUnit() ? "true" : "false");
1305 hardware::CameraInfo info;
1306 status_t res = device->getCameraInfo(&info);
1307 if (res != OK) {
1308 dprintf(fd, " <Error reading camera info: %s (%d)>\n",
1309 strerror(-res), res);
1310 } else {
1311 dprintf(fd, " Facing: %s\n",
1312 info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
1313 dprintf(fd, " Orientation: %d\n", info.orientation);
1314 }
1315 CameraMetadata info2;
1316 res = device->getCameraCharacteristics(&info2);
1317 if (res == INVALID_OPERATION) {
1318 dprintf(fd, " API2 not directly supported\n");
1319 } else if (res != OK) {
1320 dprintf(fd, " <Error reading camera characteristics: %s (%d)>\n",
1321 strerror(-res), res);
1322 } else {
1323 dprintf(fd, " API2 camera characteristics:\n");
1324 info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1325 }
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001326
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001327 // Dump characteristics of non-standalone physical camera
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001328 if (device->mIsLogicalCamera) {
1329 for (auto& id : device->mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001330 // Skip if physical id is an independent camera
1331 if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
1332 != mProviderPublicCameraIds.end()) {
1333 continue;
1334 }
1335
1336 CameraMetadata physicalInfo;
1337 status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
1338 if (status == OK) {
1339 dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
1340 physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
1341 }
1342 }
1343 }
1344
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001345 dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
1346 device->mVersion.get_major(), device->mVersion.get_minor());
1347 res = device->dumpState(fd);
1348 if (res != OK) {
1349 dprintf(fd, " <Error dumping device %s state: %s (%d)>\n",
1350 device->mName.c_str(), strerror(-res), res);
1351 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001352 }
1353 return OK;
1354}
1355
1356hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
1357 const hardware::hidl_string& cameraDeviceName,
1358 CameraDeviceStatus newStatus) {
1359 sp<StatusListener> listener;
1360 std::string id;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001361 bool initialized = false;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001362 {
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001363 std::lock_guard<std::mutex> lock(mLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001364 bool known = false;
1365 for (auto& deviceInfo : mDevices) {
1366 if (deviceInfo->mName == cameraDeviceName) {
1367 ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
1368 deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
1369 deviceInfo->mStatus = newStatus;
1370 // TODO: Handle device removal (NOT_PRESENT)
1371 id = deviceInfo->mId;
1372 known = true;
1373 break;
1374 }
1375 }
1376 // Previously unseen device; status must not be NOT_PRESENT
1377 if (!known) {
1378 if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1379 ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
1380 mProviderName.c_str(), cameraDeviceName.c_str());
1381 return hardware::Void();
1382 }
1383 addDevice(cameraDeviceName, newStatus, &id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +01001384 } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
1385 removeDevice(id);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001386 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001387 listener = mManager->getStatusListener();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001388 initialized = mInitialized;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001389 }
1390 // Call without lock held to allow reentrancy into provider manager
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001391 // Don't send the callback if providerInfo hasn't been initialized.
1392 // CameraService will initialize device status after provider is
1393 // initialized
1394 if (listener != nullptr && initialized) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001395 listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
1396 }
1397 return hardware::Void();
1398}
1399
1400hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
1401 const hardware::hidl_string& cameraDeviceName,
1402 TorchModeStatus newStatus) {
1403 sp<StatusListener> listener;
1404 std::string id;
1405 {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001406 std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001407 bool known = false;
1408 for (auto& deviceInfo : mDevices) {
1409 if (deviceInfo->mName == cameraDeviceName) {
1410 ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
1411 torchStatusToString(newStatus));
1412 id = deviceInfo->mId;
1413 known = true;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001414 if (TorchModeStatus::AVAILABLE_ON != newStatus) {
1415 mManager->removeRef(DeviceMode::TORCH, id);
1416 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001417 break;
1418 }
1419 }
1420 if (!known) {
1421 ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
1422 mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
1423 return hardware::Void();
1424 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001425 listener = mManager->getStatusListener();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001426 }
1427 // Call without lock held to allow reentrancy into provider manager
1428 if (listener != nullptr) {
1429 listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
1430 }
1431 return hardware::Void();
1432}
1433
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001434void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
1435 const wp<hidl::base::V1_0::IBase>& who) {
1436 (void) who;
1437 ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
1438 if (cookie != mId) {
1439 ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
1440 __FUNCTION__, cookie, mId);
1441 }
1442 mManager->removeProvider(mProviderName);
1443}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001444
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001445status_t CameraProviderManager::ProviderInfo::setUpVendorTags() {
1446 if (mVendorTagDescriptor != nullptr)
1447 return OK;
1448
1449 hardware::hidl_vec<VendorTagSection> vts;
1450 Status status;
1451 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001452 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1453 if (interface == nullptr) {
1454 return DEAD_OBJECT;
1455 }
1456 ret = interface->getVendorTags(
Peter Kalauskas1b3c9072018-11-07 12:41:53 -08001457 [&](auto s, const auto& vendorTagSecs) {
1458 status = s;
1459 if (s == Status::OK) {
1460 vts = vendorTagSecs;
1461 }
1462 });
1463 if (!ret.isOk()) {
1464 ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
1465 __FUNCTION__, mProviderName.c_str(), ret.description().c_str());
1466 return DEAD_OBJECT;
1467 }
1468 if (status != Status::OK) {
1469 return mapToStatusT(status);
1470 }
1471
1472 // Read all vendor tag definitions into a descriptor
1473 status_t res;
1474 if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/mVendorTagDescriptor))
1475 != OK) {
1476 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
1477 "received error %s (%d). Camera clients will not be able to use"
1478 "vendor tags", __FUNCTION__, strerror(res), res);
1479 return res;
1480 }
1481
1482 return OK;
1483}
1484
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001485status_t CameraProviderManager::ProviderInfo::notifyDeviceStateChange(
1486 hardware::hidl_bitfield<provider::V2_5::DeviceState> newDeviceState) {
1487 mDeviceState = newDeviceState;
1488 if (mMinorVersion >= 5) {
1489 // Check if the provider is currently active - not going to start it up for this notification
1490 auto interface = mSavedInterface != nullptr ? mSavedInterface : mActiveInterface.promote();
1491 if (interface != nullptr) {
1492 // Send current device state
1493 auto castResult = provider::V2_5::ICameraProvider::castFrom(interface);
1494 if (castResult.isOk()) {
1495 sp<provider::V2_5::ICameraProvider> interface_2_5 = castResult;
1496 if (interface_2_5 != nullptr) {
1497 interface_2_5->notifyDeviceStateChange(mDeviceState);
1498 }
1499 }
1500 }
1501 }
1502 return OK;
1503}
1504
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001505template<class DeviceInfoT>
1506std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
1507 CameraProviderManager::ProviderInfo::initializeDeviceInfo(
Emilian Peev71c73a22017-03-21 16:35:51 +00001508 const std::string &name, const metadata_vendor_id_t tagId,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001509 const std::string &id, uint16_t minorVersion) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001510 Status status;
1511
1512 auto cameraInterface =
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001513 startDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001514 if (cameraInterface == nullptr) return nullptr;
1515
1516 CameraResourceCost resourceCost;
1517 cameraInterface->getResourceCost([&status, &resourceCost](
1518 Status s, CameraResourceCost cost) {
1519 status = s;
1520 resourceCost = cost;
1521 });
1522 if (status != Status::OK) {
1523 ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
1524 name.c_str(), statusToString(status));
1525 return nullptr;
1526 }
Shuzhen Wang47283692018-04-24 18:05:02 -07001527
1528 for (auto& conflictName : resourceCost.conflictingDevices) {
1529 uint16_t major, minor;
1530 std::string type, id;
1531 status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
1532 if (res != OK) {
1533 ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
1534 return nullptr;
1535 }
1536 conflictName = id;
1537 }
1538
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001539 return std::unique_ptr<DeviceInfo>(
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001540 new DeviceInfoT(name, tagId, id, minorVersion, resourceCost, this,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001541 mProviderPublicCameraIds, cameraInterface));
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001542}
1543
1544template<class InterfaceT>
1545sp<InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001546CameraProviderManager::ProviderInfo::startDeviceInterface(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001547 ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
1548 name.c_str(), InterfaceT::version.get_major());
1549 return nullptr;
1550}
1551
1552template<>
1553sp<device::V1_0::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001554CameraProviderManager::ProviderInfo::startDeviceInterface
1555 <device::V1_0::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001556 Status status;
1557 sp<device::V1_0::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001558 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001559 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1560 if (interface == nullptr) {
1561 return nullptr;
1562 }
1563 ret = interface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001564 Status s, sp<device::V1_0::ICameraDevice> interface) {
1565 status = s;
1566 cameraInterface = interface;
1567 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001568 if (!ret.isOk()) {
1569 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1570 __FUNCTION__, name.c_str(), ret.description().c_str());
1571 return nullptr;
1572 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001573 if (status != Status::OK) {
1574 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1575 name.c_str(), statusToString(status));
1576 return nullptr;
1577 }
1578 return cameraInterface;
1579}
1580
1581template<>
1582sp<device::V3_2::ICameraDevice>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001583CameraProviderManager::ProviderInfo::startDeviceInterface
1584 <device::V3_2::ICameraDevice>(const std::string &name) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001585 Status status;
1586 sp<device::V3_2::ICameraDevice> cameraInterface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001587 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001588 const sp<provider::V2_4::ICameraProvider> interface = startProviderInterface();
1589 if (interface == nullptr) {
1590 return nullptr;
1591 }
1592 ret = interface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001593 Status s, sp<device::V3_2::ICameraDevice> interface) {
1594 status = s;
1595 cameraInterface = interface;
1596 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001597 if (!ret.isOk()) {
1598 ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
1599 __FUNCTION__, name.c_str(), ret.description().c_str());
1600 return nullptr;
1601 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001602 if (status != Status::OK) {
1603 ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
1604 name.c_str(), statusToString(status));
1605 return nullptr;
1606 }
1607 return cameraInterface;
1608}
1609
1610CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
1611
1612template<class InterfaceT>
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001613sp<InterfaceT> CameraProviderManager::ProviderInfo::DeviceInfo::startDeviceInterface() {
1614 sp<InterfaceT> device;
1615 ATRACE_CALL();
1616 if (mSavedInterface == nullptr) {
1617 device = mParentProvider->startDeviceInterface<InterfaceT>(mName);
1618 } else {
1619 device = (InterfaceT *) mSavedInterface.get();
1620 }
1621 return device;
1622}
1623
1624template<class InterfaceT>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001625status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
1626 bool enabled) {
1627 Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
1628 return mapToStatusT(s);
1629}
1630
1631CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001632 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001633 uint16_t minorVersion,
1634 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001635 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001636 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001637 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001638 DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001639 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001640 // Get default parameters and initialize flash unit availability
1641 // Requires powering on the camera device
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001642 hardware::Return<Status> status = interface->open(nullptr);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001643 if (!status.isOk()) {
1644 ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001645 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001646 return;
1647 }
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001648 if (status != Status::OK) {
1649 ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001650 id.c_str(), CameraProviderManager::statusToString(status));
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001651 return;
1652 }
1653 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001654 ret = interface->getParameters([this](const hardware::hidl_string& parms) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001655 mDefaultParameters.unflatten(String8(parms.c_str()));
1656 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001657 if (!ret.isOk()) {
1658 ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001659 __FUNCTION__, id.c_str(), status.description().c_str());
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001660 return;
1661 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001662 const char *flashMode =
1663 mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
1664 if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
1665 mHasFlashUnit = true;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001666 }
1667
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001668 status_t res = cacheCameraInfo(interface);
1669 if (res != OK) {
1670 ALOGE("%s: Could not cache CameraInfo", __FUNCTION__);
1671 return;
1672 }
1673
1674 ret = interface->close();
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001675 if (!ret.isOk()) {
1676 ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001677 __FUNCTION__, id.c_str(), status.description().c_str());
1678 }
1679
1680 if (!kEnableLazyHal) {
1681 // Save HAL reference indefinitely
1682 mSavedInterface = interface;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001683 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001684}
1685
1686CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
1687
1688status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001689 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001690}
1691
1692status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
1693 hardware::CameraInfo *info) const {
1694 if (info == nullptr) return BAD_VALUE;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001695 *info = mInfo;
1696 return OK;
1697}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001698
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001699status_t CameraProviderManager::ProviderInfo::DeviceInfo1::cacheCameraInfo(
1700 sp<CameraProviderManager::ProviderInfo::DeviceInfo1::InterfaceT> interface) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001701 Status status;
1702 device::V1_0::CameraInfo cInfo;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001703 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001704 ret = interface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001705 status = s;
1706 cInfo = camInfo;
1707 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001708 if (!ret.isOk()) {
1709 ALOGE("%s: Transaction error reading camera info from device %s: %s",
1710 __FUNCTION__, mId.c_str(), ret.description().c_str());
1711 return DEAD_OBJECT;
1712 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001713 if (status != Status::OK) {
1714 return mapToStatusT(status);
1715 }
1716
1717 switch(cInfo.facing) {
1718 case device::V1_0::CameraFacing::BACK:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001719 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001720 break;
1721 case device::V1_0::CameraFacing::EXTERNAL:
1722 // Map external to front for legacy API
1723 case device::V1_0::CameraFacing::FRONT:
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001724 mInfo.facing = hardware::CAMERA_FACING_FRONT;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001725 break;
1726 default:
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001727 ALOGW("%s: Device %s: Unknown camera facing: %d",
1728 __FUNCTION__, mId.c_str(), cInfo.facing);
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001729 mInfo.facing = hardware::CAMERA_FACING_BACK;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001730 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001731 mInfo.orientation = cInfo.orientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001732
1733 return OK;
1734}
1735
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001736status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001737 native_handle_t* handle = native_handle_create(1,0);
1738 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001739 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1740 if (interface == nullptr) {
1741 return DEAD_OBJECT;
1742 }
1743 hardware::Return<Status> s = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001744 native_handle_delete(handle);
1745 if (!s.isOk()) {
1746 return INVALID_OPERATION;
1747 }
1748 return mapToStatusT(s);
1749}
1750
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001751CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
Emilian Peev71c73a22017-03-21 16:35:51 +00001752 const metadata_vendor_id_t tagId, const std::string &id,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001753 uint16_t minorVersion,
1754 const CameraResourceCost& resourceCost,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001755 sp<ProviderInfo> parentProvider,
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001756 const std::vector<std::string>& publicCameraIds,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001757 sp<InterfaceT> interface) :
Emilian Peev71c73a22017-03-21 16:35:51 +00001758 DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001759 publicCameraIds, resourceCost, parentProvider) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001760 // Get camera characteristics and initialize flash unit availability
1761 Status status;
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001762 hardware::Return<void> ret;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001763 ret = interface->getCameraCharacteristics([&status, this](Status s,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001764 device::V3_2::CameraMetadata metadata) {
1765 status = s;
1766 if (s == Status::OK) {
1767 camera_metadata_t *buffer =
1768 reinterpret_cast<camera_metadata_t*>(metadata.data());
Yin-Chia Yeh238ef5f2017-04-18 15:01:15 -07001769 size_t expectedSize = metadata.size();
1770 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1771 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1772 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1773 mCameraCharacteristics = buffer;
1774 } else {
1775 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1776 status = Status::INTERNAL_ERROR;
1777 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001778 }
1779 });
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001780 if (!ret.isOk()) {
1781 ALOGE("%s: Transaction error getting camera characteristics for device %s"
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001782 " to check for a flash unit: %s", __FUNCTION__, id.c_str(),
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -07001783 ret.description().c_str());
1784 return;
1785 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001786 if (status != Status::OK) {
1787 ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001788 __FUNCTION__, id.c_str(), CameraProviderManager::statusToString(status), status);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001789 return;
1790 }
Shuzhen Wang268a1362018-10-16 16:32:59 -07001791 status_t res = fixupMonochromeTags();
1792 if (OK != res) {
1793 ALOGE("%s: Unable to fix up monochrome tags based for older HAL version: %s (%d)",
1794 __FUNCTION__, strerror(-res), res);
1795 return;
1796 }
Emilian Peev4c6d2b52019-01-04 17:13:56 +00001797 res = addDynamicDepthTags();
1798 if (OK != res) {
1799 ALOGE("%s: Failed appending dynamic depth tags: %s (%d)", __FUNCTION__, strerror(-res),
1800 res);
1801 return;
1802 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001803 camera_metadata_entry flashAvailable =
1804 mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
1805 if (flashAvailable.count == 1 &&
1806 flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
1807 mHasFlashUnit = true;
1808 } else {
1809 mHasFlashUnit = false;
1810 }
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001811
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001812 queryPhysicalCameraIds();
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001813 // Get physical camera characteristics if applicable
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001814 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001815 if (!castResult.isOk()) {
1816 ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
1817 return;
1818 }
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08001819 sp<device::V3_5::ICameraDevice> interface_3_5 = castResult;
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001820 if (interface_3_5 == nullptr) {
1821 ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
1822 return;
1823 }
1824
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07001825 if (mIsLogicalCamera) {
1826 for (auto& id : mPhysicalIds) {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001827 if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
1828 mPublicCameraIds.end()) {
1829 continue;
1830 }
1831
1832 hardware::hidl_string hidlId(id);
1833 ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
1834 [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
1835 status = s;
1836 if (s == Status::OK) {
1837 camera_metadata_t *buffer =
1838 reinterpret_cast<camera_metadata_t*>(metadata.data());
1839 size_t expectedSize = metadata.size();
1840 int res = validate_camera_metadata_structure(buffer, &expectedSize);
1841 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1842 set_camera_metadata_vendor_id(buffer, mProviderTagid);
1843 mPhysicalCameraCharacteristics[id] = buffer;
1844 } else {
1845 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1846 status = Status::INTERNAL_ERROR;
1847 }
1848 }
1849 });
1850
1851 if (!ret.isOk()) {
1852 ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001853 __FUNCTION__, id.c_str(), id.c_str(), ret.description().c_str());
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001854 return;
1855 }
1856 if (status != Status::OK) {
1857 ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
1858 __FUNCTION__, id.c_str(), mId.c_str(),
1859 CameraProviderManager::statusToString(status), status);
1860 return;
1861 }
1862 }
1863 }
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001864
1865 if (!kEnableLazyHal) {
1866 // Save HAL reference indefinitely
1867 mSavedInterface = interface;
1868 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001869}
1870
1871CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
1872
1873status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001874 return setTorchModeForDevice<InterfaceT>(enabled);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001875}
1876
1877status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
1878 hardware::CameraInfo *info) const {
1879 if (info == nullptr) return BAD_VALUE;
1880
1881 camera_metadata_ro_entry facing =
1882 mCameraCharacteristics.find(ANDROID_LENS_FACING);
1883 if (facing.count == 1) {
1884 switch (facing.data.u8[0]) {
1885 case ANDROID_LENS_FACING_BACK:
1886 info->facing = hardware::CAMERA_FACING_BACK;
1887 break;
1888 case ANDROID_LENS_FACING_EXTERNAL:
1889 // Map external to front for legacy API
1890 case ANDROID_LENS_FACING_FRONT:
1891 info->facing = hardware::CAMERA_FACING_FRONT;
1892 break;
1893 }
1894 } else {
1895 ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
1896 return NAME_NOT_FOUND;
1897 }
1898
1899 camera_metadata_ro_entry orientation =
1900 mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
1901 if (orientation.count == 1) {
1902 info->orientation = orientation.data.i32[0];
1903 } else {
1904 ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
1905 return NAME_NOT_FOUND;
1906 }
1907
1908 return OK;
1909}
Emilian Peevf53f66e2017-04-11 14:29:43 +01001910bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
1911 bool isBackwardCompatible = false;
1912 camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
1913 ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1914 for (size_t i = 0; i < caps.count; i++) {
1915 if (caps.data.u8[i] ==
1916 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
1917 isBackwardCompatible = true;
1918 break;
1919 }
1920 }
1921
1922 return isBackwardCompatible;
1923}
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001924
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001925status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) {
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001926 native_handle_t* handle = native_handle_create(1,0);
1927 handle->data[0] = fd;
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001928 const sp<InterfaceT> interface = startDeviceInterface<InterfaceT>();
1929 if (interface == nullptr) {
1930 return DEAD_OBJECT;
1931 }
1932 auto ret = interface->dumpState(handle);
Yin-Chia Yeh487785a2018-01-02 12:06:57 -08001933 native_handle_delete(handle);
1934 if (!ret.isOk()) {
1935 return INVALID_OPERATION;
1936 }
1937 return OK;
1938}
1939
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001940status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
1941 CameraMetadata *characteristics) const {
1942 if (characteristics == nullptr) return BAD_VALUE;
1943
1944 *characteristics = mCameraCharacteristics;
1945 return OK;
1946}
1947
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001948status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
1949 const std::string& physicalCameraId, CameraMetadata *characteristics) const {
1950 if (characteristics == nullptr) return BAD_VALUE;
1951 if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
1952 mPhysicalCameraCharacteristics.end()) {
1953 return NAME_NOT_FOUND;
1954 }
1955
1956 *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
1957 return OK;
1958}
1959
Emilian Peev35ae8262018-11-08 13:11:32 +00001960status_t CameraProviderManager::ProviderInfo::DeviceInfo3::isSessionConfigurationSupported(
1961 const hardware::camera::device::V3_4::StreamConfiguration &configuration,
Peter Kalauskasa29c1352018-10-10 12:05:42 -07001962 bool *status /*out*/) {
1963
1964 const sp<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT> interface =
1965 this->startDeviceInterface<CameraProviderManager::ProviderInfo::DeviceInfo3::InterfaceT>();
1966 if (interface == nullptr) {
1967 return DEAD_OBJECT;
1968 }
1969 auto castResult = device::V3_5::ICameraDevice::castFrom(interface);
Emilian Peev35ae8262018-11-08 13:11:32 +00001970 sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
1971 if (interface_3_5 == nullptr) {
1972 return INVALID_OPERATION;
1973 }
1974
1975 status_t res;
1976 Status callStatus;
1977 auto ret = interface_3_5->isStreamCombinationSupported(configuration,
1978 [&callStatus, &status] (Status s, bool combStatus) {
1979 callStatus = s;
1980 *status = combStatus;
1981 });
1982 if (ret.isOk()) {
1983 switch (callStatus) {
1984 case Status::OK:
1985 // Expected case, do nothing.
1986 res = OK;
1987 break;
1988 case Status::METHOD_NOT_SUPPORTED:
1989 res = INVALID_OPERATION;
1990 break;
1991 default:
1992 ALOGE("%s: Session configuration query failed: %d", __FUNCTION__, callStatus);
1993 res = UNKNOWN_ERROR;
1994 }
1995 } else {
1996 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, ret.description().c_str());
1997 res = UNKNOWN_ERROR;
1998 }
1999
2000 return res;
2001}
2002
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002003status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
2004 std::string *type, uint32_t *id) {
2005 // Format must be "<type>/<id>"
2006#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. " \
2007 "Should match '<type>/<id>' - "
2008
2009 if (!type || !id) return INVALID_OPERATION;
2010
2011 std::string::size_type slashIdx = name.find('/');
2012 if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
2013 ALOGE(ERROR_MSG_PREFIX
2014 "does not have / separator between type and id",
2015 __FUNCTION__, name.c_str());
2016 return BAD_VALUE;
2017 }
2018
2019 std::string typeVal = name.substr(0, slashIdx);
2020
2021 char *endPtr;
2022 errno = 0;
2023 long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
2024 if (errno != 0) {
2025 ALOGE(ERROR_MSG_PREFIX
2026 "cannot parse provider id as an integer: %s (%d)",
2027 __FUNCTION__, name.c_str(), strerror(errno), errno);
2028 return BAD_VALUE;
2029 }
2030 if (endPtr != name.c_str() + name.size()) {
2031 ALOGE(ERROR_MSG_PREFIX
2032 "provider id has unexpected length",
2033 __FUNCTION__, name.c_str());
2034 return BAD_VALUE;
2035 }
2036 if (idVal < 0) {
2037 ALOGE(ERROR_MSG_PREFIX
2038 "id is negative: %ld",
2039 __FUNCTION__, name.c_str(), idVal);
2040 return BAD_VALUE;
2041 }
2042
2043#undef ERROR_MSG_PREFIX
2044
2045 *type = typeVal;
2046 *id = static_cast<uint32_t>(idVal);
2047
2048 return OK;
2049}
2050
Emilian Peev71c73a22017-03-21 16:35:51 +00002051metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
2052 const std::string &name) {
2053 metadata_vendor_id_t ret = std::hash<std::string> {} (name);
2054 // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
2055 if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
2056 ret = 0;
2057 }
2058
2059 return ret;
2060}
2061
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002062status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
2063 uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
2064
2065 // Format must be "device@<major>.<minor>/<type>/<id>"
2066
2067#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
2068 "Should match 'device@<major>.<minor>/<type>/<id>' - "
2069
2070 if (!major || !minor || !type || !id) return INVALID_OPERATION;
2071
2072 // Verify starting prefix
2073 const char expectedPrefix[] = "device@";
2074
2075 if (name.find(expectedPrefix) != 0) {
2076 ALOGE(ERROR_MSG_PREFIX
2077 "does not start with '%s'",
2078 __FUNCTION__, name.c_str(), expectedPrefix);
2079 return BAD_VALUE;
2080 }
2081
2082 // Extract major/minor versions
2083 constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
2084 std::string::size_type dotIdx = name.find('.', atIdx);
2085 if (dotIdx == std::string::npos) {
2086 ALOGE(ERROR_MSG_PREFIX
2087 "does not have @<major>. version section",
2088 __FUNCTION__, name.c_str());
2089 return BAD_VALUE;
2090 }
2091 std::string::size_type typeSlashIdx = name.find('/', dotIdx);
2092 if (typeSlashIdx == std::string::npos) {
2093 ALOGE(ERROR_MSG_PREFIX
2094 "does not have .<minor>/ version section",
2095 __FUNCTION__, name.c_str());
2096 return BAD_VALUE;
2097 }
2098
2099 char *endPtr;
2100 errno = 0;
2101 long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
2102 if (errno != 0) {
2103 ALOGE(ERROR_MSG_PREFIX
2104 "cannot parse major version: %s (%d)",
2105 __FUNCTION__, name.c_str(), strerror(errno), errno);
2106 return BAD_VALUE;
2107 }
2108 if (endPtr != name.c_str() + dotIdx) {
2109 ALOGE(ERROR_MSG_PREFIX
2110 "major version has unexpected length",
2111 __FUNCTION__, name.c_str());
2112 return BAD_VALUE;
2113 }
2114 long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
2115 if (errno != 0) {
2116 ALOGE(ERROR_MSG_PREFIX
2117 "cannot parse minor version: %s (%d)",
2118 __FUNCTION__, name.c_str(), strerror(errno), errno);
2119 return BAD_VALUE;
2120 }
2121 if (endPtr != name.c_str() + typeSlashIdx) {
2122 ALOGE(ERROR_MSG_PREFIX
2123 "minor version has unexpected length",
2124 __FUNCTION__, name.c_str());
2125 return BAD_VALUE;
2126 }
2127 if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
2128 ALOGE(ERROR_MSG_PREFIX
2129 "major/minor version is out of range of uint16_t: %ld.%ld",
2130 __FUNCTION__, name.c_str(), majorVal, minorVal);
2131 return BAD_VALUE;
2132 }
2133
2134 // Extract type and id
2135
2136 std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
2137 if (instanceSlashIdx == std::string::npos) {
2138 ALOGE(ERROR_MSG_PREFIX
2139 "does not have /<type>/ component",
2140 __FUNCTION__, name.c_str());
2141 return BAD_VALUE;
2142 }
2143 std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
2144
2145 if (instanceSlashIdx == name.size() - 1) {
2146 ALOGE(ERROR_MSG_PREFIX
2147 "does not have an /<id> component",
2148 __FUNCTION__, name.c_str());
2149 return BAD_VALUE;
2150 }
2151 std::string idVal = name.substr(instanceSlashIdx + 1);
2152
2153#undef ERROR_MSG_PREFIX
2154
2155 *major = static_cast<uint16_t>(majorVal);
2156 *minor = static_cast<uint16_t>(minorVal);
2157 *type = typeVal;
2158 *id = idVal;
2159
2160 return OK;
2161}
2162
2163
2164
2165CameraProviderManager::ProviderInfo::~ProviderInfo() {
2166 // Destruction of ProviderInfo is only supposed to happen when the respective
2167 // CameraProvider interface dies, so do not unregister callbacks.
2168
2169}
2170
2171status_t CameraProviderManager::mapToStatusT(const Status& s) {
2172 switch(s) {
2173 case Status::OK:
2174 return OK;
2175 case Status::ILLEGAL_ARGUMENT:
2176 return BAD_VALUE;
2177 case Status::CAMERA_IN_USE:
2178 return -EBUSY;
2179 case Status::MAX_CAMERAS_IN_USE:
2180 return -EUSERS;
2181 case Status::METHOD_NOT_SUPPORTED:
2182 return UNKNOWN_TRANSACTION;
2183 case Status::OPERATION_NOT_SUPPORTED:
2184 return INVALID_OPERATION;
2185 case Status::CAMERA_DISCONNECTED:
2186 return DEAD_OBJECT;
2187 case Status::INTERNAL_ERROR:
2188 return INVALID_OPERATION;
2189 }
2190 ALOGW("Unexpected HAL status code %d", s);
2191 return INVALID_OPERATION;
2192}
2193
2194const char* CameraProviderManager::statusToString(const Status& s) {
2195 switch(s) {
2196 case Status::OK:
2197 return "OK";
2198 case Status::ILLEGAL_ARGUMENT:
2199 return "ILLEGAL_ARGUMENT";
2200 case Status::CAMERA_IN_USE:
2201 return "CAMERA_IN_USE";
2202 case Status::MAX_CAMERAS_IN_USE:
2203 return "MAX_CAMERAS_IN_USE";
2204 case Status::METHOD_NOT_SUPPORTED:
2205 return "METHOD_NOT_SUPPORTED";
2206 case Status::OPERATION_NOT_SUPPORTED:
2207 return "OPERATION_NOT_SUPPORTED";
2208 case Status::CAMERA_DISCONNECTED:
2209 return "CAMERA_DISCONNECTED";
2210 case Status::INTERNAL_ERROR:
2211 return "INTERNAL_ERROR";
2212 }
2213 ALOGW("Unexpected HAL status code %d", s);
2214 return "UNKNOWN_ERROR";
2215}
2216
2217const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
2218 switch(s) {
2219 case CameraDeviceStatus::NOT_PRESENT:
2220 return "NOT_PRESENT";
2221 case CameraDeviceStatus::PRESENT:
2222 return "PRESENT";
2223 case CameraDeviceStatus::ENUMERATING:
2224 return "ENUMERATING";
2225 }
2226 ALOGW("Unexpected HAL device status code %d", s);
2227 return "UNKNOWN_STATUS";
2228}
2229
2230const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
2231 switch(s) {
2232 case TorchModeStatus::NOT_AVAILABLE:
2233 return "NOT_AVAILABLE";
2234 case TorchModeStatus::AVAILABLE_OFF:
2235 return "AVAILABLE_OFF";
2236 case TorchModeStatus::AVAILABLE_ON:
2237 return "AVAILABLE_ON";
2238 }
2239 ALOGW("Unexpected HAL torch mode status code %d", s);
2240 return "UNKNOWN_STATUS";
2241}
2242
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002243
2244status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002245 const hardware::hidl_vec<common::V1_0::VendorTagSection>& vts,
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002246 /*out*/
2247 sp<VendorTagDescriptor>& descriptor) {
2248
2249 int tagCount = 0;
2250
2251 for (size_t s = 0; s < vts.size(); s++) {
2252 tagCount += vts[s].tags.size();
2253 }
2254
2255 if (tagCount < 0 || tagCount > INT32_MAX) {
2256 ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
2257 return BAD_VALUE;
2258 }
2259
2260 Vector<uint32_t> tagArray;
2261 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
2262 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
2263
2264
2265 sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
2266 desc->mTagCount = tagCount;
2267
2268 SortedVector<String8> sections;
2269 KeyedVector<uint32_t, String8> tagToSectionMap;
2270
2271 int idx = 0;
2272 for (size_t s = 0; s < vts.size(); s++) {
Peter Kalauskasb7bd4382018-11-15 17:19:48 -08002273 const common::V1_0::VendorTagSection& section = vts[s];
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002274 const char *sectionName = section.sectionName.c_str();
2275 if (sectionName == NULL) {
2276 ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
2277 return BAD_VALUE;
2278 }
2279 String8 sectionString(sectionName);
2280 sections.add(sectionString);
2281
2282 for (size_t j = 0; j < section.tags.size(); j++) {
2283 uint32_t tag = section.tags[j].tagId;
2284 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
2285 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
2286 return BAD_VALUE;
2287 }
2288
2289 tagArray.editItemAt(idx++) = section.tags[j].tagId;
2290
2291 const char *tagName = section.tags[j].tagName.c_str();
2292 if (tagName == NULL) {
2293 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
2294 return BAD_VALUE;
2295 }
2296 desc->mTagToNameMap.add(tag, String8(tagName));
2297 tagToSectionMap.add(tag, sectionString);
2298
2299 int tagType = (int) section.tags[j].tagType;
2300 if (tagType < 0 || tagType >= NUM_TYPES) {
2301 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
2302 return BAD_VALUE;
2303 }
2304 desc->mTagToTypeMap.add(tag, tagType);
2305 }
2306 }
2307
2308 desc->mSections = sections;
2309
2310 for (size_t i = 0; i < tagArray.size(); ++i) {
2311 uint32_t tag = tagArray[i];
2312 String8 sectionString = tagToSectionMap.valueFor(tag);
2313
2314 // Set up tag to section index map
2315 ssize_t index = sections.indexOf(sectionString);
2316 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
2317 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
2318
2319 // Set up reverse mapping
2320 ssize_t reverseIndex = -1;
2321 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
2322 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
2323 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
2324 }
2325 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
2326 }
2327
George Burgess IVa0b84962017-08-29 17:46:19 -07002328 descriptor = std::move(desc);
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002329 return OK;
2330}
2331
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002332status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
2333 CameraMetadata* characteristics) const {
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002334 auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
2335 if (deviceInfo != nullptr) {
2336 return deviceInfo->getCameraCharacteristics(characteristics);
2337 }
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002338
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07002339 // Find hidden physical camera characteristics
2340 for (auto& provider : mProviders) {
2341 for (auto& deviceInfo : provider->mDevices) {
2342 status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
2343 if (res != NAME_NOT_FOUND) return res;
2344 }
2345 }
2346
2347 return NAME_NOT_FOUND;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002348}
2349
2350void CameraProviderManager::filterLogicalCameraIdsLocked(
2351 std::vector<std::string>& deviceIds) const
2352{
2353 std::unordered_set<std::string> removedIds;
2354
2355 for (auto& deviceId : deviceIds) {
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002356 auto deviceInfo = findDeviceInfoLocked(deviceId);
2357 if (deviceInfo == nullptr) continue;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002358
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002359 if (!deviceInfo->mIsLogicalCamera) {
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002360 continue;
2361 }
Shuzhen Wang03d8cc12018-09-12 14:17:09 -07002362 // idCombo contains the ids of a logical camera and its physical cameras
2363 std::vector<std::string> idCombo = deviceInfo->mPhysicalIds;
Shuzhen Wange8aceb52018-05-21 12:00:56 -07002364 idCombo.push_back(deviceId);
2365
2366 for (auto& id : deviceIds) {
2367 auto foundId = std::find(idCombo.begin(), idCombo.end(), id);
2368 if (foundId == idCombo.end()) {
2369 continue;
2370 }
2371
2372 idCombo.erase(foundId);
2373 removedIds.insert(idCombo.begin(), idCombo.end());
2374 break;
2375 }
2376 }
2377
2378 deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
2379 [&removedIds](const std::string& s) {return removedIds.find(s) != removedIds.end();}),
2380 deviceIds.end());
2381}
Yin-Chia Yeh067428c2017-01-13 15:19:24 -08002382
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002383} // namespace android