1/*
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
23#include <algorithm>
24#include <chrono>
25#include <inttypes.h>
26#include <hidl/ServiceManagement.h>
27#include <functional>
28#include <camera_metadata_hidden.h>
29#include <android-base/parseint.h>
30
31namespace android {
32
33using namespace ::android::hardware::camera;
34using namespace ::android::hardware::camera::common::V1_0;
35
36namespace {
37// Hardcoded name for the passthrough HAL implementation, since it can't be discovered via the
38// service manager
39const std::string kLegacyProviderName("legacy/0");
40const std::string kExternalProviderName("external/0");
41
42} // anonymous namespace
43
44CameraProviderManager::HardwareServiceInteractionProxy
45CameraProviderManager::sHardwareServiceInteractionProxy{};
46
47CameraProviderManager::~CameraProviderManager() {
48}
49
50status_t CameraProviderManager::initialize(wp<CameraProviderManager::StatusListener> listener,
51        ServiceInteractionProxy* proxy) {
52    std::lock_guard<std::mutex> lock(mInterfaceMutex);
53    if (proxy == nullptr) {
54        ALOGE("%s: No valid service interaction proxy provided", __FUNCTION__);
55        return BAD_VALUE;
56    }
57    mListener = listener;
58    mServiceProxy = proxy;
59
60    // Registering will trigger notifications for all already-known providers
61    bool success = mServiceProxy->registerForNotifications(
62        /* instance name, empty means no filter */ "",
63        this);
64    if (!success) {
65        ALOGE("%s: Unable to register with hardware service manager for notifications "
66                "about camera providers", __FUNCTION__);
67        return INVALID_OPERATION;
68    }
69
70    // See if there's a passthrough HAL, but let's not complain if there's not
71    addProviderLocked(kLegacyProviderName, /*expected*/ false);
72    addProviderLocked(kExternalProviderName, /*expected*/ false);
73
74    return OK;
75}
76
77int CameraProviderManager::getCameraCount() const {
78    std::lock_guard<std::mutex> lock(mInterfaceMutex);
79    int count = 0;
80    for (auto& provider : mProviders) {
81        count += provider->mUniqueCameraIds.size();
82    }
83    return count;
84}
85
86std::vector<std::string> CameraProviderManager::getCameraDeviceIds() const {
87    std::lock_guard<std::mutex> lock(mInterfaceMutex);
88    std::vector<std::string> deviceIds;
89    for (auto& provider : mProviders) {
90        for (auto& id : provider->mUniqueCameraIds) {
91            deviceIds.push_back(id);
92        }
93    }
94    return deviceIds;
95}
96
97std::vector<std::string> CameraProviderManager::getAPI1CompatibleCameraDeviceIds() const {
98    std::lock_guard<std::mutex> lock(mInterfaceMutex);
99    std::vector<std::string> deviceIds;
100    for (auto& provider : mProviders) {
101        std::vector<std::string> providerDeviceIds = provider->mUniqueAPI1CompatibleCameraIds;
102
103        // API1 app doesn't handle logical and physical camera devices well. So
104        // for each [logical, physical1, physical2, ...] id combo, only take the
105        // first id advertised by HAL, and filter out the rest.
106        filterLogicalCameraIdsLocked(providerDeviceIds);
107
108        deviceIds.insert(deviceIds.end(), providerDeviceIds.begin(), providerDeviceIds.end());
109    }
110
111    std::sort(deviceIds.begin(), deviceIds.end(),
112            [](const std::string& a, const std::string& b) -> bool {
113                uint32_t aUint = 0, bUint = 0;
114                bool aIsUint = base::ParseUint(a, &aUint);
115                bool bIsUint = base::ParseUint(b, &bUint);
116
117                // Uint device IDs first
118                if (aIsUint && bIsUint) {
119                    return aUint < bUint;
120                } else if (aIsUint) {
121                    return true;
122                } else if (bIsUint) {
123                    return false;
124                }
125                // Simple string compare if both id are not uint
126                return a < b;
127            });
128    return deviceIds;
129}
130
131bool CameraProviderManager::isValidDevice(const std::string &id, uint16_t majorVersion) const {
132    std::lock_guard<std::mutex> lock(mInterfaceMutex);
133    return isValidDeviceLocked(id, majorVersion);
134}
135
136bool CameraProviderManager::isValidDeviceLocked(const std::string &id, uint16_t majorVersion) const {
137    for (auto& provider : mProviders) {
138        for (auto& deviceInfo : provider->mDevices) {
139            if (deviceInfo->mId == id && deviceInfo->mVersion.get_major() == majorVersion) {
140                return true;
141            }
142        }
143    }
144    return false;
145}
146
147bool CameraProviderManager::hasFlashUnit(const std::string &id) const {
148    std::lock_guard<std::mutex> lock(mInterfaceMutex);
149
150    auto deviceInfo = findDeviceInfoLocked(id);
151    if (deviceInfo == nullptr) return false;
152
153    return deviceInfo->hasFlashUnit();
154}
155
156status_t CameraProviderManager::getResourceCost(const std::string &id,
157        CameraResourceCost* cost) const {
158    std::lock_guard<std::mutex> lock(mInterfaceMutex);
159
160    auto deviceInfo = findDeviceInfoLocked(id);
161    if (deviceInfo == nullptr) return NAME_NOT_FOUND;
162
163    *cost = deviceInfo->mResourceCost;
164    return OK;
165}
166
167status_t CameraProviderManager::getCameraInfo(const std::string &id,
168        hardware::CameraInfo* info) const {
169    std::lock_guard<std::mutex> lock(mInterfaceMutex);
170
171    auto deviceInfo = findDeviceInfoLocked(id);
172    if (deviceInfo == nullptr) return NAME_NOT_FOUND;
173
174    return deviceInfo->getCameraInfo(info);
175}
176
177status_t CameraProviderManager::getCameraCharacteristics(const std::string &id,
178        CameraMetadata* characteristics) const {
179    std::lock_guard<std::mutex> lock(mInterfaceMutex);
180    return getCameraCharacteristicsLocked(id, characteristics);
181}
182
183status_t CameraProviderManager::getHighestSupportedVersion(const std::string &id,
184        hardware::hidl_version *v) {
185    std::lock_guard<std::mutex> lock(mInterfaceMutex);
186
187    hardware::hidl_version maxVersion{0,0};
188    bool found = false;
189    for (auto& provider : mProviders) {
190        for (auto& deviceInfo : provider->mDevices) {
191            if (deviceInfo->mId == id) {
192                if (deviceInfo->mVersion > maxVersion) {
193                    maxVersion = deviceInfo->mVersion;
194                    found = true;
195                }
196            }
197        }
198    }
199    if (!found) {
200        return NAME_NOT_FOUND;
201    }
202    *v = maxVersion;
203    return OK;
204}
205
206bool CameraProviderManager::supportSetTorchMode(const std::string &id) {
207    std::lock_guard<std::mutex> lock(mInterfaceMutex);
208    bool support = false;
209    for (auto& provider : mProviders) {
210        auto deviceInfo = findDeviceInfoLocked(id);
211        if (deviceInfo != nullptr) {
212            auto ret = provider->mInterface->isSetTorchModeSupported(
213                [&support](auto status, bool supported) {
214                    if (status == Status::OK) {
215                        support = supported;
216                    }
217                });
218            if (!ret.isOk()) {
219                ALOGE("%s: Transaction error checking torch mode support '%s': %s",
220                        __FUNCTION__, provider->mProviderName.c_str(), ret.description().c_str());
221            }
222            break;
223        }
224    }
225    return support;
226}
227
228status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
229    std::lock_guard<std::mutex> lock(mInterfaceMutex);
230
231    auto deviceInfo = findDeviceInfoLocked(id);
232    if (deviceInfo == nullptr) return NAME_NOT_FOUND;
233
234    return deviceInfo->setTorchMode(enabled);
235}
236
237status_t CameraProviderManager::setUpVendorTags() {
238    sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
239
240    for (auto& provider : mProviders) {
241        hardware::hidl_vec<VendorTagSection> vts;
242        Status status;
243        hardware::Return<void> ret;
244        ret = provider->mInterface->getVendorTags(
245            [&](auto s, const auto& vendorTagSecs) {
246                status = s;
247                if (s == Status::OK) {
248                    vts = vendorTagSecs;
249                }
250        });
251        if (!ret.isOk()) {
252            ALOGE("%s: Transaction error getting vendor tags from provider '%s': %s",
253                    __FUNCTION__, provider->mProviderName.c_str(), ret.description().c_str());
254            return DEAD_OBJECT;
255        }
256        if (status != Status::OK) {
257            return mapToStatusT(status);
258        }
259
260        // Read all vendor tag definitions into a descriptor
261        sp<VendorTagDescriptor> desc;
262        status_t res;
263        if ((res = HidlVendorTagDescriptor::createDescriptorFromHidl(vts, /*out*/desc))
264                != OK) {
265            ALOGE("%s: Could not generate descriptor from vendor tag operations,"
266                  "received error %s (%d). Camera clients will not be able to use"
267                  "vendor tags", __FUNCTION__, strerror(res), res);
268            return res;
269        }
270
271        tagCache->addVendorDescriptor(provider->mProviderTagid, desc);
272    }
273
274    VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
275
276    return OK;
277}
278
279status_t CameraProviderManager::openSession(const std::string &id,
280        const sp<hardware::camera::device::V3_2::ICameraDeviceCallback>& callback,
281        /*out*/
282        sp<hardware::camera::device::V3_2::ICameraDeviceSession> *session) {
283
284    std::lock_guard<std::mutex> lock(mInterfaceMutex);
285
286    auto deviceInfo = findDeviceInfoLocked(id,
287            /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
288    if (deviceInfo == nullptr) return NAME_NOT_FOUND;
289
290    auto *deviceInfo3 = static_cast<ProviderInfo::DeviceInfo3*>(deviceInfo);
291
292    Status status;
293    hardware::Return<void> ret;
294    ret = deviceInfo3->mInterface->open(callback, [&status, &session]
295            (Status s, const sp<device::V3_2::ICameraDeviceSession>& cameraSession) {
296                status = s;
297                if (status == Status::OK) {
298                    *session = cameraSession;
299                }
300            });
301    if (!ret.isOk()) {
302        ALOGE("%s: Transaction error opening a session for camera device %s: %s",
303                __FUNCTION__, id.c_str(), ret.description().c_str());
304        return DEAD_OBJECT;
305    }
306    return mapToStatusT(status);
307}
308
309status_t CameraProviderManager::openSession(const std::string &id,
310        const sp<hardware::camera::device::V1_0::ICameraDeviceCallback>& callback,
311        /*out*/
312        sp<hardware::camera::device::V1_0::ICameraDevice> *session) {
313
314    std::lock_guard<std::mutex> lock(mInterfaceMutex);
315
316    auto deviceInfo = findDeviceInfoLocked(id,
317            /*minVersion*/ {1,0}, /*maxVersion*/ {2,0});
318    if (deviceInfo == nullptr) return NAME_NOT_FOUND;
319
320    auto *deviceInfo1 = static_cast<ProviderInfo::DeviceInfo1*>(deviceInfo);
321
322    hardware::Return<Status> status = deviceInfo1->mInterface->open(callback);
323    if (!status.isOk()) {
324        ALOGE("%s: Transaction error opening a session for camera device %s: %s",
325                __FUNCTION__, id.c_str(), status.description().c_str());
326        return DEAD_OBJECT;
327    }
328    if (status == Status::OK) {
329        *session = deviceInfo1->mInterface;
330    }
331    return mapToStatusT(status);
332}
333
334
335hardware::Return<void> CameraProviderManager::onRegistration(
336        const hardware::hidl_string& /*fqName*/,
337        const hardware::hidl_string& name,
338        bool /*preexisting*/) {
339    {
340        std::lock_guard<std::mutex> lock(mInterfaceMutex);
341
342        addProviderLocked(name);
343    }
344
345    sp<StatusListener> listener = getStatusListener();
346    if (nullptr != listener.get()) {
347        listener->onNewProviderRegistered();
348    }
349
350    return hardware::Return<void>();
351}
352
353status_t CameraProviderManager::dump(int fd, const Vector<String16>& args) {
354    std::lock_guard<std::mutex> lock(mInterfaceMutex);
355
356    for (auto& provider : mProviders) {
357        provider->dump(fd, args);
358    }
359    return OK;
360}
361
362CameraProviderManager::ProviderInfo::DeviceInfo* CameraProviderManager::findDeviceInfoLocked(
363        const std::string& id,
364        hardware::hidl_version minVersion, hardware::hidl_version maxVersion) const {
365    for (auto& provider : mProviders) {
366        for (auto& deviceInfo : provider->mDevices) {
367            if (deviceInfo->mId == id &&
368                    minVersion <= deviceInfo->mVersion && maxVersion >= deviceInfo->mVersion) {
369                return deviceInfo.get();
370            }
371        }
372    }
373    return nullptr;
374}
375
376metadata_vendor_id_t CameraProviderManager::getProviderTagIdLocked(
377        const std::string& id, hardware::hidl_version minVersion,
378        hardware::hidl_version maxVersion) const {
379    metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID;
380
381    std::lock_guard<std::mutex> lock(mInterfaceMutex);
382    for (auto& provider : mProviders) {
383        for (auto& deviceInfo : provider->mDevices) {
384            if (deviceInfo->mId == id &&
385                    minVersion <= deviceInfo->mVersion &&
386                    maxVersion >= deviceInfo->mVersion) {
387                return provider->mProviderTagid;
388            }
389        }
390    }
391
392    return ret;
393}
394
395bool CameraProviderManager::isLogicalCamera(const CameraMetadata& staticInfo,
396        std::vector<std::string>* physicalCameraIds) {
397    bool isLogicalCam = false;
398    camera_metadata_ro_entry_t entryCap;
399
400    entryCap = staticInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
401    for (size_t i = 0; i < entryCap.count; ++i) {
402        uint8_t capability = entryCap.data.u8[i];
403        if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
404            isLogicalCam = true;
405            break;
406        }
407    }
408    if (!isLogicalCam) {
409        return false;
410    }
411
412    camera_metadata_ro_entry_t entryIds = staticInfo.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
413    const uint8_t* ids = entryIds.data.u8;
414    size_t start = 0;
415    for (size_t i = 0; i < entryIds.count; ++i) {
416        if (ids[i] == '\0') {
417            if (start != i) {
418                physicalCameraIds->push_back((const char*)ids+start);
419            }
420            start = i+1;
421        }
422    }
423    return true;
424}
425
426status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
427    for (const auto& providerInfo : mProviders) {
428        if (providerInfo->mProviderName == newProvider) {
429            ALOGW("%s: Camera provider HAL with name '%s' already registered", __FUNCTION__,
430                    newProvider.c_str());
431            return ALREADY_EXISTS;
432        }
433    }
434
435    sp<provider::V2_4::ICameraProvider> interface;
436    interface = mServiceProxy->getService(newProvider);
437
438    if (interface == nullptr) {
439        if (expected) {
440            ALOGE("%s: Camera provider HAL '%s' is not actually available", __FUNCTION__,
441                    newProvider.c_str());
442            return BAD_VALUE;
443        } else {
444            return OK;
445        }
446    }
447
448    sp<ProviderInfo> providerInfo =
449            new ProviderInfo(newProvider, interface, this);
450    status_t res = providerInfo->initialize();
451    if (res != OK) {
452        return res;
453    }
454
455    mProviders.push_back(providerInfo);
456
457    return OK;
458}
459
460status_t CameraProviderManager::removeProvider(const std::string& provider) {
461    std::unique_lock<std::mutex> lock(mInterfaceMutex);
462    std::vector<String8> removedDeviceIds;
463    status_t res = NAME_NOT_FOUND;
464    for (auto it = mProviders.begin(); it != mProviders.end(); it++) {
465        if ((*it)->mProviderName == provider) {
466            removedDeviceIds.reserve((*it)->mDevices.size());
467            for (auto& deviceInfo : (*it)->mDevices) {
468                removedDeviceIds.push_back(String8(deviceInfo->mId.c_str()));
469            }
470            mProviders.erase(it);
471            res = OK;
472            break;
473        }
474    }
475    if (res != OK) {
476        ALOGW("%s: Camera provider HAL with name '%s' is not registered", __FUNCTION__,
477                provider.c_str());
478    } else {
479        // Inform camera service of loss of presence for all the devices from this provider,
480        // without lock held for reentrancy
481        sp<StatusListener> listener = getStatusListener();
482        if (listener != nullptr) {
483            lock.unlock();
484            for (auto& id : removedDeviceIds) {
485                listener->onDeviceStatusChanged(id, CameraDeviceStatus::NOT_PRESENT);
486            }
487        }
488    }
489    return res;
490}
491
492sp<CameraProviderManager::StatusListener> CameraProviderManager::getStatusListener() const {
493    return mListener.promote();
494}
495
496/**** Methods for ProviderInfo ****/
497
498
499CameraProviderManager::ProviderInfo::ProviderInfo(
500        const std::string &providerName,
501        sp<provider::V2_4::ICameraProvider>& interface,
502        CameraProviderManager *manager) :
503        mProviderName(providerName),
504        mInterface(interface),
505        mProviderTagid(generateVendorTagId(providerName)),
506        mUniqueDeviceCount(0),
507        mManager(manager) {
508    (void) mManager;
509}
510
511status_t CameraProviderManager::ProviderInfo::initialize() {
512    status_t res = parseProviderName(mProviderName, &mType, &mId);
513    if (res != OK) {
514        ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);
515        return BAD_VALUE;
516    }
517    ALOGI("Connecting to new camera provider: %s, isRemote? %d",
518            mProviderName.c_str(), mInterface->isRemote());
519    // cameraDeviceStatusChange callbacks may be called (and causing new devices added)
520    // before setCallback returns
521    hardware::Return<Status> status = mInterface->setCallback(this);
522    if (!status.isOk()) {
523        ALOGE("%s: Transaction error setting up callbacks with camera provider '%s': %s",
524                __FUNCTION__, mProviderName.c_str(), status.description().c_str());
525        return DEAD_OBJECT;
526    }
527    if (status != Status::OK) {
528        ALOGE("%s: Unable to register callbacks with camera provider '%s'",
529                __FUNCTION__, mProviderName.c_str());
530        return mapToStatusT(status);
531    }
532
533    hardware::Return<bool> linked = mInterface->linkToDeath(this, /*cookie*/ mId);
534    if (!linked.isOk()) {
535        ALOGE("%s: Transaction error in linking to camera provider '%s' death: %s",
536                __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
537        return DEAD_OBJECT;
538    } else if (!linked) {
539        ALOGW("%s: Unable to link to provider '%s' death notifications",
540                __FUNCTION__, mProviderName.c_str());
541    }
542
543    // Get initial list of camera devices, if any
544    std::vector<std::string> devices;
545    hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices](
546            Status idStatus,
547            const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
548        status = idStatus;
549        if (status == Status::OK) {
550            for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
551                devices.push_back(cameraDeviceNames[i]);
552            }
553        } });
554    if (!ret.isOk()) {
555        ALOGE("%s: Transaction error in getting camera ID list from provider '%s': %s",
556                __FUNCTION__, mProviderName.c_str(), linked.description().c_str());
557        return DEAD_OBJECT;
558    }
559    if (status != Status::OK) {
560        ALOGE("%s: Unable to query for camera devices from provider '%s'",
561                __FUNCTION__, mProviderName.c_str());
562        return mapToStatusT(status);
563    }
564
565    sp<StatusListener> listener = mManager->getStatusListener();
566    for (auto& device : devices) {
567        std::string id;
568        status_t res = addDevice(device,
569                hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT, &id);
570        if (res != OK) {
571            ALOGE("%s: Unable to enumerate camera device '%s': %s (%d)",
572                    __FUNCTION__, device.c_str(), strerror(-res), res);
573            continue;
574        }
575    }
576
577    ALOGI("Camera provider %s ready with %zu camera devices",
578            mProviderName.c_str(), mDevices.size());
579
580    mInitialized = true;
581    return OK;
582}
583
584const std::string& CameraProviderManager::ProviderInfo::getType() const {
585    return mType;
586}
587
588status_t CameraProviderManager::ProviderInfo::addDevice(const std::string& name,
589        CameraDeviceStatus initialStatus, /*out*/ std::string* parsedId) {
590
591    ALOGI("Enumerating new camera device: %s", name.c_str());
592
593    uint16_t major, minor;
594    std::string type, id;
595
596    status_t res = parseDeviceName(name, &major, &minor, &type, &id);
597    if (res != OK) {
598        return res;
599    }
600    if (type != mType) {
601        ALOGE("%s: Device type %s does not match provider type %s", __FUNCTION__,
602                type.c_str(), mType.c_str());
603        return BAD_VALUE;
604    }
605    if (mManager->isValidDeviceLocked(id, major)) {
606        ALOGE("%s: Device %s: ID %s is already in use for device major version %d", __FUNCTION__,
607                name.c_str(), id.c_str(), major);
608        return BAD_VALUE;
609    }
610
611    std::unique_ptr<DeviceInfo> deviceInfo;
612    switch (major) {
613        case 1:
614            deviceInfo = initializeDeviceInfo<DeviceInfo1>(name, mProviderTagid,
615                    id, minor);
616            break;
617        case 3:
618            deviceInfo = initializeDeviceInfo<DeviceInfo3>(name, mProviderTagid,
619                    id, minor);
620            break;
621        default:
622            ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
623                    name.c_str(), major);
624            return BAD_VALUE;
625    }
626    if (deviceInfo == nullptr) return BAD_VALUE;
627    deviceInfo->mStatus = initialStatus;
628    bool isAPI1Compatible = deviceInfo->isAPI1Compatible();
629
630    mDevices.push_back(std::move(deviceInfo));
631
632    mUniqueCameraIds.insert(id);
633    if (isAPI1Compatible) {
634        mUniqueAPI1CompatibleCameraIds.push_back(id);
635    }
636
637    if (parsedId != nullptr) {
638        *parsedId = id;
639    }
640    return OK;
641}
642
643void CameraProviderManager::ProviderInfo::removeDevice(std::string id) {
644    for (auto it = mDevices.begin(); it != mDevices.end(); it++) {
645        if ((*it)->mId == id) {
646            mUniqueCameraIds.erase(id);
647            if ((*it)->isAPI1Compatible()) {
648                mUniqueAPI1CompatibleCameraIds.erase(std::remove(
649                        mUniqueAPI1CompatibleCameraIds.begin(),
650                        mUniqueAPI1CompatibleCameraIds.end(), id));
651            }
652            mDevices.erase(it);
653            break;
654        }
655    }
656}
657
658status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {
659    dprintf(fd, "== Camera Provider HAL %s (v2.4, %s) static info: %zu devices: ==\n",
660            mProviderName.c_str(), mInterface->isRemote() ? "remote" : "passthrough",
661            mDevices.size());
662
663    for (auto& device : mDevices) {
664        dprintf(fd, "== Camera HAL device %s (v%d.%d) static information: ==\n", device->mName.c_str(),
665                device->mVersion.get_major(), device->mVersion.get_minor());
666        dprintf(fd, "  Resource cost: %d\n", device->mResourceCost.resourceCost);
667        if (device->mResourceCost.conflictingDevices.size() == 0) {
668            dprintf(fd, "  Conflicting devices: None\n");
669        } else {
670            dprintf(fd, "  Conflicting devices:\n");
671            for (size_t i = 0; i < device->mResourceCost.conflictingDevices.size(); i++) {
672                dprintf(fd, "    %s\n",
673                        device->mResourceCost.conflictingDevices[i].c_str());
674            }
675        }
676        dprintf(fd, "  API1 info:\n");
677        dprintf(fd, "    Has a flash unit: %s\n",
678                device->hasFlashUnit() ? "true" : "false");
679        hardware::CameraInfo info;
680        status_t res = device->getCameraInfo(&info);
681        if (res != OK) {
682            dprintf(fd, "   <Error reading camera info: %s (%d)>\n",
683                    strerror(-res), res);
684        } else {
685            dprintf(fd, "    Facing: %s\n",
686                    info.facing == hardware::CAMERA_FACING_BACK ? "Back" : "Front");
687            dprintf(fd, "    Orientation: %d\n", info.orientation);
688        }
689        CameraMetadata info2;
690        res = device->getCameraCharacteristics(&info2);
691        if (res == INVALID_OPERATION) {
692            dprintf(fd, "  API2 not directly supported\n");
693        } else if (res != OK) {
694            dprintf(fd, "  <Error reading camera characteristics: %s (%d)>\n",
695                    strerror(-res), res);
696        } else {
697            dprintf(fd, "  API2 camera characteristics:\n");
698            info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
699        }
700
701        dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
702                device->mVersion.get_major(), device->mVersion.get_minor());
703        res = device->dumpState(fd);
704        if (res != OK) {
705            dprintf(fd, "   <Error dumping device %s state: %s (%d)>\n",
706                    device->mName.c_str(), strerror(-res), res);
707        }
708    }
709    return OK;
710}
711
712hardware::Return<void> CameraProviderManager::ProviderInfo::cameraDeviceStatusChange(
713        const hardware::hidl_string& cameraDeviceName,
714        CameraDeviceStatus newStatus) {
715    sp<StatusListener> listener;
716    std::string id;
717    bool initialized = false;
718    {
719        std::lock_guard<std::mutex> lock(mLock);
720        bool known = false;
721        for (auto& deviceInfo : mDevices) {
722            if (deviceInfo->mName == cameraDeviceName) {
723                ALOGI("Camera device %s status is now %s, was %s", cameraDeviceName.c_str(),
724                        deviceStatusToString(newStatus), deviceStatusToString(deviceInfo->mStatus));
725                deviceInfo->mStatus = newStatus;
726                // TODO: Handle device removal (NOT_PRESENT)
727                id = deviceInfo->mId;
728                known = true;
729                break;
730            }
731        }
732        // Previously unseen device; status must not be NOT_PRESENT
733        if (!known) {
734            if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
735                ALOGW("Camera provider %s says an unknown camera device %s is not present. Curious.",
736                    mProviderName.c_str(), cameraDeviceName.c_str());
737                return hardware::Void();
738            }
739            addDevice(cameraDeviceName, newStatus, &id);
740        } else if (newStatus == CameraDeviceStatus::NOT_PRESENT) {
741            removeDevice(id);
742        }
743        listener = mManager->getStatusListener();
744        initialized = mInitialized;
745    }
746    // Call without lock held to allow reentrancy into provider manager
747    // Don't send the callback if providerInfo hasn't been initialized.
748    // CameraService will initialize device status after provider is
749    // initialized
750    if (listener != nullptr && initialized) {
751        listener->onDeviceStatusChanged(String8(id.c_str()), newStatus);
752    }
753    return hardware::Void();
754}
755
756hardware::Return<void> CameraProviderManager::ProviderInfo::torchModeStatusChange(
757        const hardware::hidl_string& cameraDeviceName,
758        TorchModeStatus newStatus) {
759    sp<StatusListener> listener;
760    std::string id;
761    {
762        std::lock_guard<std::mutex> lock(mManager->mStatusListenerMutex);
763        bool known = false;
764        for (auto& deviceInfo : mDevices) {
765            if (deviceInfo->mName == cameraDeviceName) {
766                ALOGI("Camera device %s torch status is now %s", cameraDeviceName.c_str(),
767                        torchStatusToString(newStatus));
768                id = deviceInfo->mId;
769                known = true;
770                break;
771            }
772        }
773        if (!known) {
774            ALOGW("Camera provider %s says an unknown camera %s now has torch status %d. Curious.",
775                    mProviderName.c_str(), cameraDeviceName.c_str(), newStatus);
776            return hardware::Void();
777        }
778        listener = mManager->getStatusListener();
779    }
780    // Call without lock held to allow reentrancy into provider manager
781    if (listener != nullptr) {
782        listener->onTorchStatusChanged(String8(id.c_str()), newStatus);
783    }
784    return hardware::Void();
785}
786
787void CameraProviderManager::ProviderInfo::serviceDied(uint64_t cookie,
788        const wp<hidl::base::V1_0::IBase>& who) {
789    (void) who;
790    ALOGI("Camera provider '%s' has died; removing it", mProviderName.c_str());
791    if (cookie != mId) {
792        ALOGW("%s: Unexpected serviceDied cookie %" PRIu64 ", expected %" PRIu32,
793                __FUNCTION__, cookie, mId);
794    }
795    mManager->removeProvider(mProviderName);
796}
797
798template<class DeviceInfoT>
799std::unique_ptr<CameraProviderManager::ProviderInfo::DeviceInfo>
800    CameraProviderManager::ProviderInfo::initializeDeviceInfo(
801        const std::string &name, const metadata_vendor_id_t tagId,
802        const std::string &id, uint16_t minorVersion) const {
803    Status status;
804
805    auto cameraInterface =
806            getDeviceInterface<typename DeviceInfoT::InterfaceT>(name);
807    if (cameraInterface == nullptr) return nullptr;
808
809    CameraResourceCost resourceCost;
810    cameraInterface->getResourceCost([&status, &resourceCost](
811        Status s, CameraResourceCost cost) {
812                status = s;
813                resourceCost = cost;
814            });
815    if (status != Status::OK) {
816        ALOGE("%s: Unable to obtain resource costs for camera device %s: %s", __FUNCTION__,
817                name.c_str(), statusToString(status));
818        return nullptr;
819    }
820
821    for (auto& conflictName : resourceCost.conflictingDevices) {
822        uint16_t major, minor;
823        std::string type, id;
824        status_t res = parseDeviceName(conflictName, &major, &minor, &type, &id);
825        if (res != OK) {
826            ALOGE("%s: Failed to parse conflicting device %s", __FUNCTION__, conflictName.c_str());
827            return nullptr;
828        }
829        conflictName = id;
830    }
831
832    return std::unique_ptr<DeviceInfo>(
833        new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
834                cameraInterface));
835}
836
837template<class InterfaceT>
838sp<InterfaceT>
839CameraProviderManager::ProviderInfo::getDeviceInterface(const std::string &name) const {
840    ALOGE("%s: Device %s: Unknown HIDL device HAL major version %d:", __FUNCTION__,
841            name.c_str(), InterfaceT::version.get_major());
842    return nullptr;
843}
844
845template<>
846sp<device::V1_0::ICameraDevice>
847CameraProviderManager::ProviderInfo::getDeviceInterface
848        <device::V1_0::ICameraDevice>(const std::string &name) const {
849    Status status;
850    sp<device::V1_0::ICameraDevice> cameraInterface;
851    hardware::Return<void> ret;
852    ret = mInterface->getCameraDeviceInterface_V1_x(name, [&status, &cameraInterface](
853        Status s, sp<device::V1_0::ICameraDevice> interface) {
854                status = s;
855                cameraInterface = interface;
856            });
857    if (!ret.isOk()) {
858        ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
859                __FUNCTION__, name.c_str(), ret.description().c_str());
860        return nullptr;
861    }
862    if (status != Status::OK) {
863        ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
864                name.c_str(), statusToString(status));
865        return nullptr;
866    }
867    return cameraInterface;
868}
869
870template<>
871sp<device::V3_2::ICameraDevice>
872CameraProviderManager::ProviderInfo::getDeviceInterface
873        <device::V3_2::ICameraDevice>(const std::string &name) const {
874    Status status;
875    sp<device::V3_2::ICameraDevice> cameraInterface;
876    hardware::Return<void> ret;
877    ret = mInterface->getCameraDeviceInterface_V3_x(name, [&status, &cameraInterface](
878        Status s, sp<device::V3_2::ICameraDevice> interface) {
879                status = s;
880                cameraInterface = interface;
881            });
882    if (!ret.isOk()) {
883        ALOGE("%s: Transaction error trying to obtain interface for camera device %s: %s",
884                __FUNCTION__, name.c_str(), ret.description().c_str());
885        return nullptr;
886    }
887    if (status != Status::OK) {
888        ALOGE("%s: Unable to obtain interface for camera device %s: %s", __FUNCTION__,
889                name.c_str(), statusToString(status));
890        return nullptr;
891    }
892    return cameraInterface;
893}
894
895CameraProviderManager::ProviderInfo::DeviceInfo::~DeviceInfo() {}
896
897template<class InterfaceT>
898status_t CameraProviderManager::ProviderInfo::DeviceInfo::setTorchMode(InterfaceT& interface,
899        bool enabled) {
900    Status s = interface->setTorchMode(enabled ? TorchMode::ON : TorchMode::OFF);
901    return mapToStatusT(s);
902}
903
904CameraProviderManager::ProviderInfo::DeviceInfo1::DeviceInfo1(const std::string& name,
905        const metadata_vendor_id_t tagId, const std::string &id,
906        uint16_t minorVersion,
907        const CameraResourceCost& resourceCost,
908        sp<InterfaceT> interface) :
909        DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
910                   resourceCost),
911        mInterface(interface) {
912    // Get default parameters and initialize flash unit availability
913    // Requires powering on the camera device
914    hardware::Return<Status> status = mInterface->open(nullptr);
915    if (!status.isOk()) {
916        ALOGE("%s: Transaction error opening camera device %s to check for a flash unit: %s",
917                __FUNCTION__, mId.c_str(), status.description().c_str());
918        return;
919    }
920    if (status != Status::OK) {
921        ALOGE("%s: Unable to open camera device %s to check for a flash unit: %s", __FUNCTION__,
922                mId.c_str(), CameraProviderManager::statusToString(status));
923        return;
924    }
925    hardware::Return<void> ret;
926    ret = mInterface->getParameters([this](const hardware::hidl_string& parms) {
927                mDefaultParameters.unflatten(String8(parms.c_str()));
928            });
929    if (!ret.isOk()) {
930        ALOGE("%s: Transaction error reading camera device %s params to check for a flash unit: %s",
931                __FUNCTION__, mId.c_str(), status.description().c_str());
932        return;
933    }
934    const char *flashMode =
935            mDefaultParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);
936    if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {
937        mHasFlashUnit = true;
938    }
939
940    ret = mInterface->close();
941    if (!ret.isOk()) {
942        ALOGE("%s: Transaction error closing camera device %s after check for a flash unit: %s",
943                __FUNCTION__, mId.c_str(), status.description().c_str());
944    }
945}
946
947CameraProviderManager::ProviderInfo::DeviceInfo1::~DeviceInfo1() {}
948
949status_t CameraProviderManager::ProviderInfo::DeviceInfo1::setTorchMode(bool enabled) {
950    return DeviceInfo::setTorchMode(mInterface, enabled);
951}
952
953status_t CameraProviderManager::ProviderInfo::DeviceInfo1::getCameraInfo(
954        hardware::CameraInfo *info) const {
955    if (info == nullptr) return BAD_VALUE;
956
957    Status status;
958    device::V1_0::CameraInfo cInfo;
959    hardware::Return<void> ret;
960    ret = mInterface->getCameraInfo([&status, &cInfo](Status s, device::V1_0::CameraInfo camInfo) {
961                status = s;
962                cInfo = camInfo;
963            });
964    if (!ret.isOk()) {
965        ALOGE("%s: Transaction error reading camera info from device %s: %s",
966                __FUNCTION__, mId.c_str(), ret.description().c_str());
967        return DEAD_OBJECT;
968    }
969    if (status != Status::OK) {
970        return mapToStatusT(status);
971    }
972
973    switch(cInfo.facing) {
974        case device::V1_0::CameraFacing::BACK:
975            info->facing = hardware::CAMERA_FACING_BACK;
976            break;
977        case device::V1_0::CameraFacing::EXTERNAL:
978            // Map external to front for legacy API
979        case device::V1_0::CameraFacing::FRONT:
980            info->facing = hardware::CAMERA_FACING_FRONT;
981            break;
982        default:
983            ALOGW("%s: Device %s: Unknown camera facing: %d",
984                    __FUNCTION__, mId.c_str(), cInfo.facing);
985            info->facing = hardware::CAMERA_FACING_BACK;
986    }
987    info->orientation = cInfo.orientation;
988
989    return OK;
990}
991
992status_t CameraProviderManager::ProviderInfo::DeviceInfo1::dumpState(int fd) const {
993    native_handle_t* handle = native_handle_create(1,0);
994    handle->data[0] = fd;
995    hardware::Return<Status> s = mInterface->dumpState(handle);
996    native_handle_delete(handle);
997    if (!s.isOk()) {
998        return INVALID_OPERATION;
999    }
1000    return mapToStatusT(s);
1001}
1002
1003CameraProviderManager::ProviderInfo::DeviceInfo3::DeviceInfo3(const std::string& name,
1004        const metadata_vendor_id_t tagId, const std::string &id,
1005        uint16_t minorVersion,
1006        const CameraResourceCost& resourceCost,
1007        sp<InterfaceT> interface) :
1008        DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
1009                   resourceCost),
1010        mInterface(interface) {
1011    // Get camera characteristics and initialize flash unit availability
1012    Status status;
1013    hardware::Return<void> ret;
1014    ret = mInterface->getCameraCharacteristics([&status, this](Status s,
1015                    device::V3_2::CameraMetadata metadata) {
1016                status = s;
1017                if (s == Status::OK) {
1018                    camera_metadata_t *buffer =
1019                            reinterpret_cast<camera_metadata_t*>(metadata.data());
1020                    size_t expectedSize = metadata.size();
1021                    int res = validate_camera_metadata_structure(buffer, &expectedSize);
1022                    if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
1023                        set_camera_metadata_vendor_id(buffer, mProviderTagid);
1024                        mCameraCharacteristics = buffer;
1025                    } else {
1026                        ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
1027                        status = Status::INTERNAL_ERROR;
1028                    }
1029                }
1030            });
1031    if (!ret.isOk()) {
1032        ALOGE("%s: Transaction error getting camera characteristics for device %s"
1033                " to check for a flash unit: %s", __FUNCTION__, mId.c_str(),
1034                ret.description().c_str());
1035        return;
1036    }
1037    if (status != Status::OK) {
1038        ALOGE("%s: Unable to get camera characteristics for device %s: %s (%d)",
1039                __FUNCTION__, mId.c_str(), CameraProviderManager::statusToString(status), status);
1040        return;
1041    }
1042    camera_metadata_entry flashAvailable =
1043            mCameraCharacteristics.find(ANDROID_FLASH_INFO_AVAILABLE);
1044    if (flashAvailable.count == 1 &&
1045            flashAvailable.data.u8[0] == ANDROID_FLASH_INFO_AVAILABLE_TRUE) {
1046        mHasFlashUnit = true;
1047    } else {
1048        mHasFlashUnit = false;
1049    }
1050}
1051
1052CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
1053
1054status_t CameraProviderManager::ProviderInfo::DeviceInfo3::setTorchMode(bool enabled) {
1055    return DeviceInfo::setTorchMode(mInterface, enabled);
1056}
1057
1058status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraInfo(
1059        hardware::CameraInfo *info) const {
1060    if (info == nullptr) return BAD_VALUE;
1061
1062    camera_metadata_ro_entry facing =
1063            mCameraCharacteristics.find(ANDROID_LENS_FACING);
1064    if (facing.count == 1) {
1065        switch (facing.data.u8[0]) {
1066            case ANDROID_LENS_FACING_BACK:
1067                info->facing = hardware::CAMERA_FACING_BACK;
1068                break;
1069            case ANDROID_LENS_FACING_EXTERNAL:
1070                // Map external to front for legacy API
1071            case ANDROID_LENS_FACING_FRONT:
1072                info->facing = hardware::CAMERA_FACING_FRONT;
1073                break;
1074        }
1075    } else {
1076        ALOGE("%s: Unable to find android.lens.facing static metadata", __FUNCTION__);
1077        return NAME_NOT_FOUND;
1078    }
1079
1080    camera_metadata_ro_entry orientation =
1081            mCameraCharacteristics.find(ANDROID_SENSOR_ORIENTATION);
1082    if (orientation.count == 1) {
1083        info->orientation = orientation.data.i32[0];
1084    } else {
1085        ALOGE("%s: Unable to find android.sensor.orientation static metadata", __FUNCTION__);
1086        return NAME_NOT_FOUND;
1087    }
1088
1089    return OK;
1090}
1091bool CameraProviderManager::ProviderInfo::DeviceInfo3::isAPI1Compatible() const {
1092    bool isBackwardCompatible = false;
1093    camera_metadata_ro_entry_t caps = mCameraCharacteristics.find(
1094            ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
1095    for (size_t i = 0; i < caps.count; i++) {
1096        if (caps.data.u8[i] ==
1097                ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
1098            isBackwardCompatible = true;
1099            break;
1100        }
1101    }
1102
1103    return isBackwardCompatible;
1104}
1105
1106status_t CameraProviderManager::ProviderInfo::DeviceInfo3::dumpState(int fd) const {
1107    native_handle_t* handle = native_handle_create(1,0);
1108    handle->data[0] = fd;
1109    auto ret = mInterface->dumpState(handle);
1110    native_handle_delete(handle);
1111    if (!ret.isOk()) {
1112        return INVALID_OPERATION;
1113    }
1114    return OK;
1115}
1116
1117status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getCameraCharacteristics(
1118        CameraMetadata *characteristics) const {
1119    if (characteristics == nullptr) return BAD_VALUE;
1120
1121    *characteristics = mCameraCharacteristics;
1122    return OK;
1123}
1124
1125status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
1126        std::string *type, uint32_t *id) {
1127    // Format must be "<type>/<id>"
1128#define ERROR_MSG_PREFIX "%s: Invalid provider name '%s'. "       \
1129    "Should match '<type>/<id>' - "
1130
1131    if (!type || !id) return INVALID_OPERATION;
1132
1133    std::string::size_type slashIdx = name.find('/');
1134    if (slashIdx == std::string::npos || slashIdx == name.size() - 1) {
1135        ALOGE(ERROR_MSG_PREFIX
1136                "does not have / separator between type and id",
1137                __FUNCTION__, name.c_str());
1138        return BAD_VALUE;
1139    }
1140
1141    std::string typeVal = name.substr(0, slashIdx);
1142
1143    char *endPtr;
1144    errno = 0;
1145    long idVal = strtol(name.c_str() + slashIdx + 1, &endPtr, 10);
1146    if (errno != 0) {
1147        ALOGE(ERROR_MSG_PREFIX
1148                "cannot parse provider id as an integer: %s (%d)",
1149                __FUNCTION__, name.c_str(), strerror(errno), errno);
1150        return BAD_VALUE;
1151    }
1152    if (endPtr != name.c_str() + name.size()) {
1153        ALOGE(ERROR_MSG_PREFIX
1154                "provider id has unexpected length",
1155                __FUNCTION__, name.c_str());
1156        return BAD_VALUE;
1157    }
1158    if (idVal < 0) {
1159        ALOGE(ERROR_MSG_PREFIX
1160                "id is negative: %ld",
1161                __FUNCTION__, name.c_str(), idVal);
1162        return BAD_VALUE;
1163    }
1164
1165#undef ERROR_MSG_PREFIX
1166
1167    *type = typeVal;
1168    *id = static_cast<uint32_t>(idVal);
1169
1170    return OK;
1171}
1172
1173metadata_vendor_id_t CameraProviderManager::ProviderInfo::generateVendorTagId(
1174        const std::string &name) {
1175    metadata_vendor_id_t ret = std::hash<std::string> {} (name);
1176    // CAMERA_METADATA_INVALID_VENDOR_ID is not a valid hash value
1177    if (CAMERA_METADATA_INVALID_VENDOR_ID == ret) {
1178        ret = 0;
1179    }
1180
1181    return ret;
1182}
1183
1184status_t CameraProviderManager::ProviderInfo::parseDeviceName(const std::string& name,
1185        uint16_t *major, uint16_t *minor, std::string *type, std::string *id) {
1186
1187    // Format must be "device@<major>.<minor>/<type>/<id>"
1188
1189#define ERROR_MSG_PREFIX "%s: Invalid device name '%s'. " \
1190    "Should match 'device@<major>.<minor>/<type>/<id>' - "
1191
1192    if (!major || !minor || !type || !id) return INVALID_OPERATION;
1193
1194    // Verify starting prefix
1195    const char expectedPrefix[] = "device@";
1196
1197    if (name.find(expectedPrefix) != 0) {
1198        ALOGE(ERROR_MSG_PREFIX
1199                "does not start with '%s'",
1200                __FUNCTION__, name.c_str(), expectedPrefix);
1201        return BAD_VALUE;
1202    }
1203
1204    // Extract major/minor versions
1205    constexpr std::string::size_type atIdx = sizeof(expectedPrefix) - 2;
1206    std::string::size_type dotIdx = name.find('.', atIdx);
1207    if (dotIdx == std::string::npos) {
1208        ALOGE(ERROR_MSG_PREFIX
1209                "does not have @<major>. version section",
1210                __FUNCTION__, name.c_str());
1211        return BAD_VALUE;
1212    }
1213    std::string::size_type typeSlashIdx = name.find('/', dotIdx);
1214    if (typeSlashIdx == std::string::npos) {
1215        ALOGE(ERROR_MSG_PREFIX
1216                "does not have .<minor>/ version section",
1217                __FUNCTION__, name.c_str());
1218        return BAD_VALUE;
1219    }
1220
1221    char *endPtr;
1222    errno = 0;
1223    long majorVal = strtol(name.c_str() + atIdx + 1, &endPtr, 10);
1224    if (errno != 0) {
1225        ALOGE(ERROR_MSG_PREFIX
1226                "cannot parse major version: %s (%d)",
1227                __FUNCTION__, name.c_str(), strerror(errno), errno);
1228        return BAD_VALUE;
1229    }
1230    if (endPtr != name.c_str() + dotIdx) {
1231        ALOGE(ERROR_MSG_PREFIX
1232                "major version has unexpected length",
1233                __FUNCTION__, name.c_str());
1234        return BAD_VALUE;
1235    }
1236    long minorVal = strtol(name.c_str() + dotIdx + 1, &endPtr, 10);
1237    if (errno != 0) {
1238        ALOGE(ERROR_MSG_PREFIX
1239                "cannot parse minor version: %s (%d)",
1240                __FUNCTION__, name.c_str(), strerror(errno), errno);
1241        return BAD_VALUE;
1242    }
1243    if (endPtr != name.c_str() + typeSlashIdx) {
1244        ALOGE(ERROR_MSG_PREFIX
1245                "minor version has unexpected length",
1246                __FUNCTION__, name.c_str());
1247        return BAD_VALUE;
1248    }
1249    if (majorVal < 0 || majorVal > UINT16_MAX || minorVal < 0 || minorVal > UINT16_MAX) {
1250        ALOGE(ERROR_MSG_PREFIX
1251                "major/minor version is out of range of uint16_t: %ld.%ld",
1252                __FUNCTION__, name.c_str(), majorVal, minorVal);
1253        return BAD_VALUE;
1254    }
1255
1256    // Extract type and id
1257
1258    std::string::size_type instanceSlashIdx = name.find('/', typeSlashIdx + 1);
1259    if (instanceSlashIdx == std::string::npos) {
1260        ALOGE(ERROR_MSG_PREFIX
1261                "does not have /<type>/ component",
1262                __FUNCTION__, name.c_str());
1263        return BAD_VALUE;
1264    }
1265    std::string typeVal = name.substr(typeSlashIdx + 1, instanceSlashIdx - typeSlashIdx - 1);
1266
1267    if (instanceSlashIdx == name.size() - 1) {
1268        ALOGE(ERROR_MSG_PREFIX
1269                "does not have an /<id> component",
1270                __FUNCTION__, name.c_str());
1271        return BAD_VALUE;
1272    }
1273    std::string idVal = name.substr(instanceSlashIdx + 1);
1274
1275#undef ERROR_MSG_PREFIX
1276
1277    *major = static_cast<uint16_t>(majorVal);
1278    *minor = static_cast<uint16_t>(minorVal);
1279    *type = typeVal;
1280    *id = idVal;
1281
1282    return OK;
1283}
1284
1285
1286
1287CameraProviderManager::ProviderInfo::~ProviderInfo() {
1288    // Destruction of ProviderInfo is only supposed to happen when the respective
1289    // CameraProvider interface dies, so do not unregister callbacks.
1290
1291}
1292
1293status_t CameraProviderManager::mapToStatusT(const Status& s)  {
1294    switch(s) {
1295        case Status::OK:
1296            return OK;
1297        case Status::ILLEGAL_ARGUMENT:
1298            return BAD_VALUE;
1299        case Status::CAMERA_IN_USE:
1300            return -EBUSY;
1301        case Status::MAX_CAMERAS_IN_USE:
1302            return -EUSERS;
1303        case Status::METHOD_NOT_SUPPORTED:
1304            return UNKNOWN_TRANSACTION;
1305        case Status::OPERATION_NOT_SUPPORTED:
1306            return INVALID_OPERATION;
1307        case Status::CAMERA_DISCONNECTED:
1308            return DEAD_OBJECT;
1309        case Status::INTERNAL_ERROR:
1310            return INVALID_OPERATION;
1311    }
1312    ALOGW("Unexpected HAL status code %d", s);
1313    return INVALID_OPERATION;
1314}
1315
1316const char* CameraProviderManager::statusToString(const Status& s) {
1317    switch(s) {
1318        case Status::OK:
1319            return "OK";
1320        case Status::ILLEGAL_ARGUMENT:
1321            return "ILLEGAL_ARGUMENT";
1322        case Status::CAMERA_IN_USE:
1323            return "CAMERA_IN_USE";
1324        case Status::MAX_CAMERAS_IN_USE:
1325            return "MAX_CAMERAS_IN_USE";
1326        case Status::METHOD_NOT_SUPPORTED:
1327            return "METHOD_NOT_SUPPORTED";
1328        case Status::OPERATION_NOT_SUPPORTED:
1329            return "OPERATION_NOT_SUPPORTED";
1330        case Status::CAMERA_DISCONNECTED:
1331            return "CAMERA_DISCONNECTED";
1332        case Status::INTERNAL_ERROR:
1333            return "INTERNAL_ERROR";
1334    }
1335    ALOGW("Unexpected HAL status code %d", s);
1336    return "UNKNOWN_ERROR";
1337}
1338
1339const char* CameraProviderManager::deviceStatusToString(const CameraDeviceStatus& s) {
1340    switch(s) {
1341        case CameraDeviceStatus::NOT_PRESENT:
1342            return "NOT_PRESENT";
1343        case CameraDeviceStatus::PRESENT:
1344            return "PRESENT";
1345        case CameraDeviceStatus::ENUMERATING:
1346            return "ENUMERATING";
1347    }
1348    ALOGW("Unexpected HAL device status code %d", s);
1349    return "UNKNOWN_STATUS";
1350}
1351
1352const char* CameraProviderManager::torchStatusToString(const TorchModeStatus& s) {
1353    switch(s) {
1354        case TorchModeStatus::NOT_AVAILABLE:
1355            return "NOT_AVAILABLE";
1356        case TorchModeStatus::AVAILABLE_OFF:
1357            return "AVAILABLE_OFF";
1358        case TorchModeStatus::AVAILABLE_ON:
1359            return "AVAILABLE_ON";
1360    }
1361    ALOGW("Unexpected HAL torch mode status code %d", s);
1362    return "UNKNOWN_STATUS";
1363}
1364
1365
1366status_t HidlVendorTagDescriptor::createDescriptorFromHidl(
1367        const hardware::hidl_vec<hardware::camera::common::V1_0::VendorTagSection>& vts,
1368        /*out*/
1369        sp<VendorTagDescriptor>& descriptor) {
1370
1371    int tagCount = 0;
1372
1373    for (size_t s = 0; s < vts.size(); s++) {
1374        tagCount += vts[s].tags.size();
1375    }
1376
1377    if (tagCount < 0 || tagCount > INT32_MAX) {
1378        ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
1379        return BAD_VALUE;
1380    }
1381
1382    Vector<uint32_t> tagArray;
1383    LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
1384            "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
1385
1386
1387    sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
1388    desc->mTagCount = tagCount;
1389
1390    SortedVector<String8> sections;
1391    KeyedVector<uint32_t, String8> tagToSectionMap;
1392
1393    int idx = 0;
1394    for (size_t s = 0; s < vts.size(); s++) {
1395        const hardware::camera::common::V1_0::VendorTagSection& section = vts[s];
1396        const char *sectionName = section.sectionName.c_str();
1397        if (sectionName == NULL) {
1398            ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
1399            return BAD_VALUE;
1400        }
1401        String8 sectionString(sectionName);
1402        sections.add(sectionString);
1403
1404        for (size_t j = 0; j < section.tags.size(); j++) {
1405            uint32_t tag = section.tags[j].tagId;
1406            if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
1407                ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
1408                return BAD_VALUE;
1409            }
1410
1411            tagArray.editItemAt(idx++) = section.tags[j].tagId;
1412
1413            const char *tagName = section.tags[j].tagName.c_str();
1414            if (tagName == NULL) {
1415                ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
1416                return BAD_VALUE;
1417            }
1418            desc->mTagToNameMap.add(tag, String8(tagName));
1419            tagToSectionMap.add(tag, sectionString);
1420
1421            int tagType = (int) section.tags[j].tagType;
1422            if (tagType < 0 || tagType >= NUM_TYPES) {
1423                ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
1424                return BAD_VALUE;
1425            }
1426            desc->mTagToTypeMap.add(tag, tagType);
1427        }
1428    }
1429
1430    desc->mSections = sections;
1431
1432    for (size_t i = 0; i < tagArray.size(); ++i) {
1433        uint32_t tag = tagArray[i];
1434        String8 sectionString = tagToSectionMap.valueFor(tag);
1435
1436        // Set up tag to section index map
1437        ssize_t index = sections.indexOf(sectionString);
1438        LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
1439        desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
1440
1441        // Set up reverse mapping
1442        ssize_t reverseIndex = -1;
1443        if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
1444            KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
1445            reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
1446        }
1447        desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
1448    }
1449
1450    descriptor = std::move(desc);
1451    return OK;
1452}
1453
1454status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
1455        CameraMetadata* characteristics) const {
1456    auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
1457    if (deviceInfo == nullptr) return NAME_NOT_FOUND;
1458
1459    return deviceInfo->getCameraCharacteristics(characteristics);
1460}
1461
1462void CameraProviderManager::filterLogicalCameraIdsLocked(
1463        std::vector<std::string>& deviceIds) const
1464{
1465    std::unordered_set<std::string> removedIds;
1466
1467    for (auto& deviceId : deviceIds) {
1468        CameraMetadata info;
1469        status_t res = getCameraCharacteristicsLocked(deviceId, &info);
1470        if (res != OK) {
1471            ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
1472                    deviceId.c_str());
1473            return;
1474        }
1475
1476        // idCombo contains the ids of a logical camera and its physical cameras
1477        std::vector<std::string> idCombo;
1478        bool logicalCamera = CameraProviderManager::isLogicalCamera(info, &idCombo);
1479        if (!logicalCamera) {
1480            continue;
1481        }
1482        idCombo.push_back(deviceId);
1483
1484        for (auto& id : deviceIds) {
1485            auto foundId = std::find(idCombo.begin(), idCombo.end(), id);
1486            if (foundId == idCombo.end()) {
1487                continue;
1488            }
1489
1490            idCombo.erase(foundId);
1491            removedIds.insert(idCombo.begin(), idCombo.end());
1492            break;
1493        }
1494    }
1495
1496    deviceIds.erase(std::remove_if(deviceIds.begin(), deviceIds.end(),
1497            [&removedIds](const std::string& s) {return removedIds.find(s) != removedIds.end();}),
1498            deviceIds.end());
1499}
1500
1501} // namespace android
1502