CameraService.cpp revision 71c73a2985a7ac65ee597be3441ab300fa56e22e 
1/*
2 * Copyright (C) 2008 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 "CameraService"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <algorithm>
22#include <climits>
23#include <stdio.h>
24#include <cstring>
25#include <ctime>
26#include <string>
27#include <sys/types.h>
28#include <inttypes.h>
29#include <pthread.h>
30
31#include <android/hardware/ICamera.h>
32#include <android/hardware/ICameraClient.h>
33
34#include <android-base/macros.h>
35#include <android-base/parseint.h>
36#include <binder/AppOpsManager.h>
37#include <binder/IPCThreadState.h>
38#include <binder/IServiceManager.h>
39#include <binder/MemoryBase.h>
40#include <binder/MemoryHeapBase.h>
41#include <binder/ProcessInfoService.h>
42#include <cutils/atomic.h>
43#include <cutils/properties.h>
44#include <gui/Surface.h>
45#include <hardware/hardware.h>
46#include <memunreachable/memunreachable.h>
47#include <media/AudioSystem.h>
48#include <media/IMediaHTTPService.h>
49#include <media/mediaplayer.h>
50#include <mediautils/BatteryNotifier.h>
51#include <utils/Errors.h>
52#include <utils/Log.h>
53#include <utils/String16.h>
54#include <utils/Trace.h>
55#include <private/android_filesystem_config.h>
56#include <system/camera_vendor_tags.h>
57#include <system/camera_metadata.h>
58
59#include <system/camera.h>
60
61#include "CameraService.h"
62#include "api1/CameraClient.h"
63#include "api1/Camera2Client.h"
64#include "api2/CameraDeviceClient.h"
65#include "utils/CameraTraces.h"
66
67namespace {
68    const char* kPermissionServiceName = "permission";
69}; // namespace anonymous
70
71namespace android {
72
73using binder::Status;
74using hardware::ICamera;
75using hardware::ICameraClient;
76using hardware::ICameraServiceListener;
77using hardware::camera::common::V1_0::CameraDeviceStatus;
78using hardware::camera::common::V1_0::TorchModeStatus;
79
80// ----------------------------------------------------------------------------
81// Logging support -- this is for debugging only
82// Use "adb shell dumpsys media.camera -v 1" to change it.
83volatile int32_t gLogLevel = 0;
84
85#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
86#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
87
88static void setLogLevel(int level) {
89    android_atomic_write(level, &gLogLevel);
90}
91
92// Convenience methods for constructing binder::Status objects for error returns
93
94#define STATUS_ERROR(errorCode, errorString) \
95    binder::Status::fromServiceSpecificError(errorCode, \
96            String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString))
97
98#define STATUS_ERROR_FMT(errorCode, errorString, ...) \
99    binder::Status::fromServiceSpecificError(errorCode, \
100            String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, \
101                    __VA_ARGS__))
102
103// ----------------------------------------------------------------------------
104
105extern "C" {
106static void camera_device_status_change(
107        const struct camera_module_callbacks* callbacks,
108        int camera_id,
109        int new_status) {
110    sp<CameraService> cs = const_cast<CameraService*>(
111            static_cast<const CameraService*>(callbacks));
112    String8 id = String8::format("%d", camera_id);
113
114    CameraDeviceStatus newStatus{CameraDeviceStatus::NOT_PRESENT};
115    switch (new_status) {
116        case CAMERA_DEVICE_STATUS_NOT_PRESENT:
117            newStatus = CameraDeviceStatus::NOT_PRESENT;
118            break;
119        case CAMERA_DEVICE_STATUS_PRESENT:
120            newStatus = CameraDeviceStatus::PRESENT;
121            break;
122        case CAMERA_DEVICE_STATUS_ENUMERATING:
123            newStatus = CameraDeviceStatus::ENUMERATING;
124            break;
125        default:
126            ALOGW("Unknown device status change to %d", new_status);
127            break;
128    }
129    cs->onDeviceStatusChanged(id, newStatus);
130}
131
132static void torch_mode_status_change(
133        const struct camera_module_callbacks* callbacks,
134        const char* camera_id,
135        int new_status) {
136    if (!callbacks || !camera_id) {
137        ALOGE("%s invalid parameters. callbacks %p, camera_id %p", __FUNCTION__,
138                callbacks, camera_id);
139    }
140    sp<CameraService> cs = const_cast<CameraService*>(
141                                static_cast<const CameraService*>(callbacks));
142
143    TorchModeStatus status;
144    switch (new_status) {
145        case TORCH_MODE_STATUS_NOT_AVAILABLE:
146            status = TorchModeStatus::NOT_AVAILABLE;
147            break;
148        case TORCH_MODE_STATUS_AVAILABLE_OFF:
149            status = TorchModeStatus::AVAILABLE_OFF;
150            break;
151        case TORCH_MODE_STATUS_AVAILABLE_ON:
152            status = TorchModeStatus::AVAILABLE_ON;
153            break;
154        default:
155            ALOGE("Unknown torch status %d", new_status);
156            return;
157    }
158
159    cs->onTorchStatusChanged(
160        String8(camera_id),
161        status);
162}
163} // extern "C"
164
165// ----------------------------------------------------------------------------
166
167CameraService::CameraService() :
168        mEventLog(DEFAULT_EVENT_LOG_LENGTH),
169        mNumberOfCameras(0), mNumberOfNormalCameras(0),
170        mSoundRef(0), mInitialized(false), mModule(nullptr) {
171    ALOGI("CameraService started (pid=%d)", getpid());
172
173    this->camera_device_status_change = android::camera_device_status_change;
174    this->torch_mode_status_change = android::torch_mode_status_change;
175
176    mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);
177}
178
179void CameraService::onFirstRef()
180{
181    ALOGI("CameraService process starting");
182
183    BnCameraService::onFirstRef();
184
185    // Update battery life tracking if service is restarting
186    BatteryNotifier& notifier(BatteryNotifier::getInstance());
187    notifier.noteResetCamera();
188    notifier.noteResetFlashlight();
189
190    status_t res = INVALID_OPERATION;
191
192    bool disableTreble = property_get_bool("camera.disable_treble", false);
193    if (disableTreble) {
194        ALOGI("Treble disabled - using legacy path");
195        res = loadLegacyHalModule();
196    } else {
197        res = enumerateProviders();
198    }
199    if (res == OK) {
200        mInitialized = true;
201    }
202
203    CameraService::pingCameraServiceProxy();
204}
205
206status_t CameraService::loadLegacyHalModule() {
207    camera_module_t *rawModule;
208    int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
209            (const hw_module_t **)&rawModule);
210    if (err < 0) {
211        ALOGE("Could not load camera HAL module: %d (%s)", err, strerror(-err));
212        logServiceError("Could not load camera HAL module", err);
213        return INVALID_OPERATION;
214    }
215
216    mModule = new CameraModule(rawModule);
217    err = mModule->init();
218    if (err != OK) {
219        ALOGE("Could not initialize camera HAL module: %d (%s)", err,
220            strerror(-err));
221        logServiceError("Could not initialize camera HAL module", err);
222
223        delete mModule;
224        mModule = nullptr;
225        return INVALID_OPERATION;
226    }
227    ALOGI("Loaded \"%s\" camera module", mModule->getModuleName());
228
229    mNumberOfCameras = mModule->getNumberOfCameras();
230    mNumberOfNormalCameras = mNumberOfCameras;
231
232    // Setup vendor tags before we call get_camera_info the first time
233    // because HAL might need to setup static vendor keys in get_camera_info
234    VendorTagDescriptor::clearGlobalVendorTagDescriptor();
235    if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_2) {
236        setUpVendorTags();
237    }
238
239    mFlashlight = new CameraFlashlight(mModule, this);
240    status_t res = mFlashlight->findFlashUnits();
241    if (res) {
242        // impossible because we haven't open any camera devices.
243        ALOGE("Failed to find flash units.");
244    }
245
246    int latestStrangeCameraId = INT_MAX;
247    for (int i = 0; i < mNumberOfCameras; i++) {
248        String8 cameraId = String8::format("%d", i);
249
250        // Get camera info
251
252        struct camera_info info;
253        bool haveInfo = true;
254        status_t rc = mModule->getCameraInfo(i, &info);
255        if (rc != NO_ERROR) {
256            ALOGE("%s: Received error loading camera info for device %d, cost and"
257                    " conflicting devices fields set to defaults for this device.",
258                    __FUNCTION__, i);
259            haveInfo = false;
260        }
261
262        // Check for backwards-compatibility support
263        if (haveInfo) {
264            if (checkCameraCapabilities(i, info, &latestStrangeCameraId) != OK) {
265                delete mModule;
266                mModule = nullptr;
267                return INVALID_OPERATION;
268            }
269        }
270
271        // Defaults to use for cost and conflicting devices
272        int cost = 100;
273        char** conflicting_devices = nullptr;
274        size_t conflicting_devices_length = 0;
275
276        // If using post-2.4 module version, query the cost + conflicting devices from the HAL
277        if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 && haveInfo) {
278            cost = info.resource_cost;
279            conflicting_devices = info.conflicting_devices;
280            conflicting_devices_length = info.conflicting_devices_length;
281        }
282
283        std::set<String8> conflicting;
284        for (size_t i = 0; i < conflicting_devices_length; i++) {
285            conflicting.emplace(String8(conflicting_devices[i]));
286        }
287
288        // Initialize state for each camera device
289        {
290            Mutex::Autolock lock(mCameraStatesLock);
291            mCameraStates.emplace(cameraId, std::make_shared<CameraState>(cameraId, cost,
292                    conflicting));
293        }
294
295        if (mFlashlight->hasFlashUnit(cameraId)) {
296            mTorchStatusMap.add(cameraId,
297                    TorchModeStatus::AVAILABLE_OFF);
298        }
299    }
300
301    if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_1) {
302        mModule->setCallbacks(this);
303    }
304
305    return OK;
306}
307
308status_t CameraService::enumerateProviders() {
309    mCameraProviderManager = new CameraProviderManager();
310    status_t res;
311    res = mCameraProviderManager->initialize(this);
312    if (res != OK) {
313        ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
314                __FUNCTION__, strerror(-res), res);
315        return res;
316    }
317
318    mNumberOfCameras = mCameraProviderManager->getCameraCount();
319    mNumberOfNormalCameras = mCameraProviderManager->getStandardCameraCount();
320
321    // Setup vendor tags before we call get_camera_info the first time
322    // because HAL might need to setup static vendor keys in get_camera_info
323    // TODO: maybe put this into CameraProviderManager::initialize()?
324    mCameraProviderManager->setUpVendorTags();
325
326    mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
327    res = mFlashlight->findFlashUnits();
328    if (res != OK) {
329        ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
330    }
331
332    // TODO: Verify device versions are in support
333
334    for (auto& cameraId : mCameraProviderManager->getCameraDeviceIds()) {
335        hardware::camera::common::V1_0::CameraResourceCost cost;
336        res = mCameraProviderManager->getResourceCost(cameraId, &cost);
337        if (res != OK) {
338            ALOGE("Failed to query device resource cost: %s (%d)", strerror(-res), res);
339            continue;
340        }
341        std::set<String8> conflicting;
342        for (size_t i = 0; i < cost.conflictingDevices.size(); i++) {
343            conflicting.emplace(String8(cost.conflictingDevices[i].c_str()));
344        }
345        String8 id8 = String8(cameraId.c_str());
346
347        Mutex::Autolock lock(mCameraStatesLock);
348        mCameraStates.emplace(id8,
349            std::make_shared<CameraState>(id8, cost.resourceCost, conflicting));
350
351        if (mFlashlight->hasFlashUnit(id8)) {
352            mTorchStatusMap.add(id8,
353                TorchModeStatus::AVAILABLE_OFF);
354        }
355    }
356
357    return OK;
358}
359
360
361sp<ICameraServiceProxy> CameraService::getCameraServiceProxy() {
362    sp<ICameraServiceProxy> proxyBinder = nullptr;
363#ifndef __BRILLO__
364    sp<IServiceManager> sm = defaultServiceManager();
365    // Use checkService because cameraserver normally starts before the
366    // system server and the proxy service. So the long timeout that getService
367    // has before giving up is inappropriate.
368    sp<IBinder> binder = sm->checkService(String16("media.camera.proxy"));
369    if (binder != nullptr) {
370        proxyBinder = interface_cast<ICameraServiceProxy>(binder);
371    }
372#endif
373    return proxyBinder;
374}
375
376void CameraService::pingCameraServiceProxy() {
377    sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
378    if (proxyBinder == nullptr) return;
379    proxyBinder->pingForUserUpdate();
380}
381
382CameraService::~CameraService() {
383    if (mModule) {
384        delete mModule;
385        mModule = nullptr;
386    }
387    VendorTagDescriptor::clearGlobalVendorTagDescriptor();
388}
389
390void CameraService::onDeviceStatusChanged(const String8& id,
391        CameraDeviceStatus newHalStatus) {
392    ALOGI("%s: Status changed for cameraId=%s, newStatus=%d", __FUNCTION__,
393            id.string(), newHalStatus);
394
395    StatusInternal newStatus = mapToInternal(newHalStatus);
396
397    std::shared_ptr<CameraState> state = getCameraState(id);
398
399    if (state == nullptr) {
400        ALOGE("%s: Bad camera ID %s", __FUNCTION__, id.string());
401        return;
402    }
403
404    StatusInternal oldStatus = state->getStatus();
405
406    if (oldStatus == newStatus) {
407        ALOGE("%s: State transition to the same status %#x not allowed", __FUNCTION__, newStatus);
408        return;
409    }
410
411    if (newStatus == StatusInternal::NOT_PRESENT) {
412        logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus,
413                newStatus));
414        sp<BasicClient> clientToDisconnect;
415        {
416            // Don't do this in updateStatus to avoid deadlock over mServiceLock
417            Mutex::Autolock lock(mServiceLock);
418
419            // Set the device status to NOT_PRESENT, clients will no longer be able to connect
420            // to this device until the status changes
421            updateStatus(StatusInternal::NOT_PRESENT, id);
422
423            // Remove cached shim parameters
424            state->setShimParams(CameraParameters());
425
426            // Remove the client from the list of active clients, if there is one
427            clientToDisconnect = removeClientLocked(id);
428        }
429
430        // Disconnect client
431        if (clientToDisconnect.get() != nullptr) {
432            ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL",
433                    __FUNCTION__, id.string());
434            // Notify the client of disconnection
435            clientToDisconnect->notifyError(
436                    hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
437                    CaptureResultExtras{});
438            // Ensure not in binder RPC so client disconnect PID checks work correctly
439            LOG_ALWAYS_FATAL_IF(getCallingPid() != getpid(),
440                    "onDeviceStatusChanged must be called from the camera service process!");
441            clientToDisconnect->disconnect();
442        }
443
444    } else {
445        if (oldStatus == StatusInternal::NOT_PRESENT) {
446            logDeviceAdded(id, String8::format("Device status changed from %d to %d", oldStatus,
447                    newStatus));
448        }
449        updateStatus(newStatus, id);
450    }
451
452}
453
454void CameraService::onTorchStatusChanged(const String8& cameraId,
455        TorchModeStatus newStatus) {
456    Mutex::Autolock al(mTorchStatusMutex);
457    onTorchStatusChangedLocked(cameraId, newStatus);
458}
459
460void CameraService::onTorchStatusChangedLocked(const String8& cameraId,
461        TorchModeStatus newStatus) {
462    ALOGI("%s: Torch status changed for cameraId=%s, newStatus=%d",
463            __FUNCTION__, cameraId.string(), newStatus);
464
465    TorchModeStatus status;
466    status_t res = getTorchStatusLocked(cameraId, &status);
467    if (res) {
468        ALOGE("%s: cannot get torch status of camera %s: %s (%d)",
469                __FUNCTION__, cameraId.string(), strerror(-res), res);
470        return;
471    }
472    if (status == newStatus) {
473        return;
474    }
475
476    res = setTorchStatusLocked(cameraId, newStatus);
477    if (res) {
478        ALOGE("%s: Failed to set the torch status to %d: %s (%d)", __FUNCTION__,
479                (uint32_t)newStatus, strerror(-res), res);
480        return;
481    }
482
483    {
484        // Update battery life logging for flashlight
485        Mutex::Autolock al(mTorchUidMapMutex);
486        auto iter = mTorchUidMap.find(cameraId);
487        if (iter != mTorchUidMap.end()) {
488            int oldUid = iter->second.second;
489            int newUid = iter->second.first;
490            BatteryNotifier& notifier(BatteryNotifier::getInstance());
491            if (oldUid != newUid) {
492                // If the UID has changed, log the status and update current UID in mTorchUidMap
493                if (status == TorchModeStatus::AVAILABLE_ON) {
494                    notifier.noteFlashlightOff(cameraId, oldUid);
495                }
496                if (newStatus == TorchModeStatus::AVAILABLE_ON) {
497                    notifier.noteFlashlightOn(cameraId, newUid);
498                }
499                iter->second.second = newUid;
500            } else {
501                // If the UID has not changed, log the status
502                if (newStatus == TorchModeStatus::AVAILABLE_ON) {
503                    notifier.noteFlashlightOn(cameraId, oldUid);
504                } else {
505                    notifier.noteFlashlightOff(cameraId, oldUid);
506                }
507            }
508        }
509    }
510
511    {
512        Mutex::Autolock lock(mStatusListenerLock);
513        for (auto& i : mListenerList) {
514            i->onTorchStatusChanged(mapToInterface(newStatus), String16{cameraId});
515        }
516    }
517}
518
519Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) {
520    ATRACE_CALL();
521    switch (type) {
522        case CAMERA_TYPE_BACKWARD_COMPATIBLE:
523            *numCameras = mNumberOfNormalCameras;
524            break;
525        case CAMERA_TYPE_ALL:
526            *numCameras = mNumberOfCameras;
527            break;
528        default:
529            ALOGW("%s: Unknown camera type %d",
530                    __FUNCTION__, type);
531            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
532                    "Unknown camera type %d", type);
533    }
534    return Status::ok();
535}
536
537Status CameraService::getCameraInfo(int cameraId,
538        CameraInfo* cameraInfo) {
539    ATRACE_CALL();
540    if (!mInitialized) {
541        return STATUS_ERROR(ERROR_DISCONNECTED,
542                "Camera subsystem is not available");
543    }
544
545    if (cameraId < 0 || cameraId >= mNumberOfCameras) {
546        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
547                "CameraId is not valid");
548    }
549
550    Status ret = Status::ok();
551    if (mModule != nullptr) {
552        struct camera_info info;
553        ret = filterGetInfoErrorCode(mModule->getCameraInfo(cameraId, &info));
554
555        if (ret.isOk()) {
556            cameraInfo->facing = info.facing;
557            cameraInfo->orientation = info.orientation;
558            // CameraInfo is for android.hardware.Camera which does not
559            // support external camera facing. The closest approximation would be
560            // front camera.
561            if (cameraInfo->facing == CAMERA_FACING_EXTERNAL) {
562                cameraInfo->facing = hardware::CAMERA_FACING_FRONT;
563            }
564        }
565    } else {
566        status_t err = mCameraProviderManager->getCameraInfo(std::to_string(cameraId), cameraInfo);
567        if (err != OK) {
568            ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
569                    "Error retrieving camera info from device %d: %s (%d)", cameraId,
570                    strerror(-err), err);
571        }
572    }
573    return ret;
574}
575
576int CameraService::cameraIdToInt(const String8& cameraId) {
577    int id;
578    bool success = base::ParseInt(cameraId.string(), &id, 0);
579    if (!success) {
580        return -1;
581    }
582    return id;
583}
584
585Status CameraService::getCameraCharacteristics(const String16& cameraId,
586        CameraMetadata* cameraInfo) {
587    ATRACE_CALL();
588    if (!cameraInfo) {
589        ALOGE("%s: cameraInfo is NULL", __FUNCTION__);
590        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "cameraInfo is NULL");
591    }
592
593    if (!mInitialized) {
594        ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
595        return STATUS_ERROR(ERROR_DISCONNECTED,
596                "Camera subsystem is not available");;
597    }
598
599    Status ret{};
600
601    if (mModule != nullptr) {
602        int id = cameraIdToInt(String8(cameraId));
603
604        if (id < 0 || id >= mNumberOfCameras) {
605            ALOGE("%s: Invalid camera id: %d", __FUNCTION__, id);
606            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
607                    "Invalid camera id: %d", id);
608        }
609
610        int version = getDeviceVersion(String8(cameraId));
611        if (version < CAMERA_DEVICE_API_VERSION_3_0) {
612            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT, "Can't get camera characteristics"
613                    " for devices with HAL version < 3.0, %d is version %x", id, version);
614        }
615
616        struct camera_info info;
617        ret = filterGetInfoErrorCode(mModule->getCameraInfo(id, &info));
618        if (ret.isOk()) {
619            *cameraInfo = info.static_camera_characteristics;
620        }
621    } else {
622        status_t res = mCameraProviderManager->getCameraCharacteristics(
623                String8(cameraId).string(), cameraInfo);
624        if (res != OK) {
625            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Unable to retrieve camera "
626                    "characteristics for device %s: %s (%d)", String8(cameraId).string(),
627                    strerror(-res), res);
628        }
629    }
630
631    return ret;
632}
633
634int CameraService::getCallingPid() {
635    return IPCThreadState::self()->getCallingPid();
636}
637
638int CameraService::getCallingUid() {
639    return IPCThreadState::self()->getCallingUid();
640}
641
642String8 CameraService::getFormattedCurrentTime() {
643    time_t now = time(nullptr);
644    char formattedTime[64];
645    strftime(formattedTime, sizeof(formattedTime), "%m-%d %H:%M:%S", localtime(&now));
646    return String8(formattedTime);
647}
648
649Status CameraService::getCameraVendorTagDescriptor(
650        /*out*/
651        hardware::camera2::params::VendorTagDescriptor* desc) {
652    ATRACE_CALL();
653    if (!mInitialized) {
654        ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
655        return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available");
656    }
657    sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor();
658    if (globalDescriptor != nullptr) {
659        *desc = *(globalDescriptor.get());
660    }
661    return Status::ok();
662}
663
664Status CameraService::getCameraVendorTagCache(
665        /*out*/ hardware::camera2::params::VendorTagDescriptorCache* cache) {
666    ATRACE_CALL();
667    if (!mInitialized) {
668        ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
669        return STATUS_ERROR(ERROR_DISCONNECTED,
670                "Camera subsystem not available");
671    }
672    sp<VendorTagDescriptorCache> globalCache =
673            VendorTagDescriptorCache::getGlobalVendorTagCache();
674    if (globalCache != nullptr) {
675        *cache = *(globalCache.get());
676    }
677    return Status::ok();
678}
679
680int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
681    ATRACE_CALL();
682
683    int deviceVersion = 0;
684
685    if (mModule != nullptr) {
686        int id = cameraIdToInt(cameraId);
687        if (id < 0) return -1;
688
689        struct camera_info info;
690        if (mModule->getCameraInfo(id, &info) != OK) {
691            return -1;
692        }
693
694        if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
695            deviceVersion = info.device_version;
696        } else {
697            deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
698        }
699
700        if (facing) {
701            *facing = info.facing;
702        }
703    } else {
704        status_t res;
705        hardware::hidl_version maxVersion{0,0};
706        res = mCameraProviderManager->getHighestSupportedVersion(cameraId.string(),
707                &maxVersion);
708        if (res != OK) return -1;
709        deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());
710
711        hardware::CameraInfo info;
712        if (facing) {
713            res = mCameraProviderManager->getCameraInfo(cameraId.string(), &info);
714            if (res != OK) return -1;
715            *facing = info.facing;
716        }
717    }
718    return deviceVersion;
719}
720
721Status CameraService::filterGetInfoErrorCode(status_t err) {
722    switch(err) {
723        case NO_ERROR:
724            return Status::ok();
725        case BAD_VALUE:
726            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
727                    "CameraId is not valid for HAL module");
728        case NO_INIT:
729            return STATUS_ERROR(ERROR_DISCONNECTED,
730                    "Camera device not available");
731        default:
732            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
733                    "Camera HAL encountered error %d: %s",
734                    err, strerror(-err));
735    }
736}
737
738bool CameraService::setUpVendorTags() {
739    ATRACE_CALL();
740    if (mModule == nullptr) return false;
741
742    vendor_tag_ops_t vOps = vendor_tag_ops_t();
743
744    // Check if vendor operations have been implemented
745    if (!mModule->isVendorTagDefined()) {
746        ALOGI("%s: No vendor tags defined for this device.", __FUNCTION__);
747        return false;
748    }
749
750    mModule->getVendorTagOps(&vOps);
751
752    // Ensure all vendor operations are present
753    if (vOps.get_tag_count == NULL || vOps.get_all_tags == NULL ||
754            vOps.get_section_name == NULL || vOps.get_tag_name == NULL ||
755            vOps.get_tag_type == NULL) {
756        ALOGE("%s: Vendor tag operations not fully defined. Ignoring definitions."
757               , __FUNCTION__);
758        return false;
759    }
760
761    // Read all vendor tag definitions into a descriptor
762    sp<VendorTagDescriptor> desc;
763    status_t res;
764    if ((res = VendorTagDescriptor::createDescriptorFromOps(&vOps, /*out*/desc))
765            != OK) {
766        ALOGE("%s: Could not generate descriptor from vendor tag operations,"
767              "received error %s (%d). Camera clients will not be able to use"
768              "vendor tags", __FUNCTION__, strerror(res), res);
769        return false;
770    }
771
772    // Set the global descriptor to use with camera metadata
773    VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
774    return true;
775}
776
777Status CameraService::makeClient(const sp<CameraService>& cameraService,
778        const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
779        int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
780        int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
781        /*out*/sp<BasicClient>* client) {
782
783    if (halVersion < 0 || halVersion == deviceVersion) {
784        // Default path: HAL version is unspecified by caller, create CameraClient
785        // based on device version reported by the HAL.
786        switch(deviceVersion) {
787          case CAMERA_DEVICE_API_VERSION_1_0:
788            if (effectiveApiLevel == API_1) {  // Camera1 API route
789                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
790                *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
791                        facing, clientPid, clientUid, getpid(), legacyMode);
792            } else { // Camera2 API route
793                ALOGW("Camera using old HAL version: %d", deviceVersion);
794                return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
795                        "Camera device \"%s\" HAL version %d does not support camera2 API",
796                        cameraId.string(), deviceVersion);
797            }
798            break;
799          case CAMERA_DEVICE_API_VERSION_3_0:
800          case CAMERA_DEVICE_API_VERSION_3_1:
801          case CAMERA_DEVICE_API_VERSION_3_2:
802          case CAMERA_DEVICE_API_VERSION_3_3:
803          case CAMERA_DEVICE_API_VERSION_3_4:
804            if (effectiveApiLevel == API_1) { // Camera1 API route
805                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
806                *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
807                        facing, clientPid, clientUid, servicePid, legacyMode);
808            } else { // Camera2 API route
809                sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
810                        static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
811                *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
812                        facing, clientPid, clientUid, servicePid);
813            }
814            break;
815          default:
816            // Should not be reachable
817            ALOGE("Unknown camera device HAL version: %d", deviceVersion);
818            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
819                    "Camera device \"%s\" has unknown HAL version %d",
820                    cameraId.string(), deviceVersion);
821        }
822    } else {
823        // A particular HAL version is requested by caller. Create CameraClient
824        // based on the requested HAL version.
825        if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
826            halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
827            // Only support higher HAL version device opened as HAL1.0 device.
828            sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
829            *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
830                    facing, clientPid, clientUid, servicePid, legacyMode);
831        } else {
832            // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
833            ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
834                    " opened as HAL %x device", halVersion, deviceVersion,
835                    CAMERA_DEVICE_API_VERSION_1_0);
836            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
837                    "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
838                    cameraId.string(), deviceVersion, halVersion);
839        }
840    }
841    return Status::ok();
842}
843
844String8 CameraService::toString(std::set<userid_t> intSet) {
845    String8 s("");
846    bool first = true;
847    for (userid_t i : intSet) {
848        if (first) {
849            s.appendFormat("%d", i);
850            first = false;
851        } else {
852            s.appendFormat(", %d", i);
853        }
854    }
855    return s;
856}
857
858int32_t CameraService::mapToInterface(TorchModeStatus status) {
859    int32_t serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
860    switch (status) {
861        case TorchModeStatus::NOT_AVAILABLE:
862            serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
863            break;
864        case TorchModeStatus::AVAILABLE_OFF:
865            serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF;
866            break;
867        case TorchModeStatus::AVAILABLE_ON:
868            serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON;
869            break;
870        default:
871            ALOGW("Unknown new flash status: %d", status);
872    }
873    return serviceStatus;
874}
875
876CameraService::StatusInternal CameraService::mapToInternal(CameraDeviceStatus status) {
877    StatusInternal serviceStatus = StatusInternal::NOT_PRESENT;
878    switch (status) {
879        case CameraDeviceStatus::NOT_PRESENT:
880            serviceStatus = StatusInternal::NOT_PRESENT;
881            break;
882        case CameraDeviceStatus::PRESENT:
883            serviceStatus = StatusInternal::PRESENT;
884            break;
885        case CameraDeviceStatus::ENUMERATING:
886            serviceStatus = StatusInternal::ENUMERATING;
887            break;
888        default:
889            ALOGW("Unknown new HAL device status: %d", status);
890    }
891    return serviceStatus;
892}
893
894int32_t CameraService::mapToInterface(StatusInternal status) {
895    int32_t serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
896    switch (status) {
897        case StatusInternal::NOT_PRESENT:
898            serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
899            break;
900        case StatusInternal::PRESENT:
901            serviceStatus = ICameraServiceListener::STATUS_PRESENT;
902            break;
903        case StatusInternal::ENUMERATING:
904            serviceStatus = ICameraServiceListener::STATUS_ENUMERATING;
905            break;
906        case StatusInternal::NOT_AVAILABLE:
907            serviceStatus = ICameraServiceListener::STATUS_NOT_AVAILABLE;
908            break;
909        case StatusInternal::UNKNOWN:
910            serviceStatus = ICameraServiceListener::STATUS_UNKNOWN;
911            break;
912        default:
913            ALOGW("Unknown new internal device status: %d", status);
914    }
915    return serviceStatus;
916}
917
918Status CameraService::initializeShimMetadata(int cameraId) {
919    int uid = getCallingUid();
920
921    String16 internalPackageName("cameraserver");
922    String8 id = String8::format("%d", cameraId);
923    Status ret = Status::ok();
924    sp<Client> tmp = nullptr;
925    if (!(ret = connectHelper<ICameraClient,Client>(
926            sp<ICameraClient>{nullptr}, id, static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
927            internalPackageName, uid, USE_CALLING_PID,
928            API_1, /*legacyMode*/ false, /*shimUpdateOnly*/ true,
929            /*out*/ tmp)
930            ).isOk()) {
931        ALOGE("%s: Error initializing shim metadata: %s", __FUNCTION__, ret.toString8().string());
932    }
933    return ret;
934}
935
936Status CameraService::getLegacyParametersLazy(int cameraId,
937        /*out*/
938        CameraParameters* parameters) {
939
940    ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId);
941
942    Status ret = Status::ok();
943
944    if (parameters == NULL) {
945        ALOGE("%s: parameters must not be null", __FUNCTION__);
946        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
947    }
948
949    String8 id = String8::format("%d", cameraId);
950
951    // Check if we already have parameters
952    {
953        // Scope for service lock
954        Mutex::Autolock lock(mServiceLock);
955        auto cameraState = getCameraState(id);
956        if (cameraState == nullptr) {
957            ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
958            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
959                    "Invalid camera ID: %s", id.string());
960        }
961        CameraParameters p = cameraState->getShimParams();
962        if (!p.isEmpty()) {
963            *parameters = p;
964            return ret;
965        }
966    }
967
968    int64_t token = IPCThreadState::self()->clearCallingIdentity();
969    ret = initializeShimMetadata(cameraId);
970    IPCThreadState::self()->restoreCallingIdentity(token);
971    if (!ret.isOk()) {
972        // Error already logged by callee
973        return ret;
974    }
975
976    // Check for parameters again
977    {
978        // Scope for service lock
979        Mutex::Autolock lock(mServiceLock);
980        auto cameraState = getCameraState(id);
981        if (cameraState == nullptr) {
982            ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
983            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
984                    "Invalid camera ID: %s", id.string());
985        }
986        CameraParameters p = cameraState->getShimParams();
987        if (!p.isEmpty()) {
988            *parameters = p;
989            return ret;
990        }
991    }
992
993    ALOGE("%s: Parameters were not initialized, or were empty.  Device may not be present.",
994            __FUNCTION__);
995    return STATUS_ERROR(ERROR_INVALID_OPERATION, "Unable to initialize legacy parameters");
996}
997
998// Can camera service trust the caller based on the calling UID?
999static bool isTrustedCallingUid(uid_t uid) {
1000    switch (uid) {
1001        case AID_MEDIA:        // mediaserver
1002        case AID_CAMERASERVER: // cameraserver
1003        case AID_RADIO:        // telephony
1004            return true;
1005        default:
1006            return false;
1007    }
1008}
1009
1010Status CameraService::validateConnectLocked(const String8& cameraId,
1011        const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid,
1012        /*out*/int& originalClientPid) const {
1013
1014#ifdef __BRILLO__
1015    UNUSED(clientName8);
1016    UNUSED(clientUid);
1017    UNUSED(clientPid);
1018    UNUSED(originalClientPid);
1019#else
1020    Status allowed = validateClientPermissionsLocked(cameraId, clientName8, clientUid, clientPid,
1021            originalClientPid);
1022    if (!allowed.isOk()) {
1023        return allowed;
1024    }
1025#endif  // __BRILLO__
1026
1027    int callingPid = getCallingPid();
1028
1029    if (!mInitialized) {
1030        ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)",
1031                callingPid);
1032        return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1033                "No camera HAL module available to open camera device \"%s\"", cameraId.string());
1034    }
1035
1036    if (getCameraState(cameraId) == nullptr) {
1037        ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
1038                cameraId.string());
1039        return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1040                "No camera device with ID \"%s\" available", cameraId.string());
1041    }
1042
1043    status_t err = checkIfDeviceIsUsable(cameraId);
1044    if (err != NO_ERROR) {
1045        switch(err) {
1046            case -ENODEV:
1047            case -EBUSY:
1048                return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1049                        "No camera device with ID \"%s\" currently available", cameraId.string());
1050            default:
1051                return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1052                        "Unknown error connecting to ID \"%s\"", cameraId.string());
1053        }
1054    }
1055    return Status::ok();
1056}
1057
1058Status CameraService::validateClientPermissionsLocked(const String8& cameraId,
1059        const String8& clientName8, int& clientUid, int& clientPid,
1060        /*out*/int& originalClientPid) const {
1061    int callingPid = getCallingPid();
1062    int callingUid = getCallingUid();
1063
1064    // Check if we can trust clientUid
1065    if (clientUid == USE_CALLING_UID) {
1066        clientUid = callingUid;
1067    } else if (!isTrustedCallingUid(callingUid)) {
1068        ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
1069                "(don't trust clientUid %d)", callingPid, callingUid, clientUid);
1070        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1071                "Untrusted caller (calling PID %d, UID %d) trying to "
1072                "forward camera access to camera %s for client %s (PID %d, UID %d)",
1073                callingPid, callingUid, cameraId.string(),
1074                clientName8.string(), clientUid, clientPid);
1075    }
1076
1077    // Check if we can trust clientPid
1078    if (clientPid == USE_CALLING_PID) {
1079        clientPid = callingPid;
1080    } else if (!isTrustedCallingUid(callingUid)) {
1081        ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
1082                "(don't trust clientPid %d)", callingPid, callingUid, clientPid);
1083        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1084                "Untrusted caller (calling PID %d, UID %d) trying to "
1085                "forward camera access to camera %s for client %s (PID %d, UID %d)",
1086                callingPid, callingUid, cameraId.string(),
1087                clientName8.string(), clientUid, clientPid);
1088    }
1089
1090    // If it's not calling from cameraserver, check the permission.
1091    if (callingPid != getpid() &&
1092            !checkPermission(String16("android.permission.CAMERA"), clientPid, clientUid)) {
1093        ALOGE("Permission Denial: can't use the camera pid=%d, uid=%d", clientPid, clientUid);
1094        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1095                "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" without camera permission",
1096                clientName8.string(), clientUid, clientPid, cameraId.string());
1097    }
1098
1099    // Only use passed in clientPid to check permission. Use calling PID as the client PID that's
1100    // connected to camera service directly.
1101    originalClientPid = clientPid;
1102    clientPid = callingPid;
1103
1104    userid_t clientUserId = multiuser_get_user_id(clientUid);
1105
1106    // Only allow clients who are being used by the current foreground device user, unless calling
1107    // from our own process.
1108    if (callingPid != getpid() && (mAllowedUsers.find(clientUserId) == mAllowedUsers.end())) {
1109        ALOGE("CameraService::connect X (PID %d) rejected (cannot connect from "
1110                "device user %d, currently allowed device users: %s)", callingPid, clientUserId,
1111                toString(mAllowedUsers).string());
1112        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1113                "Callers from device user %d are not currently allowed to connect to camera \"%s\"",
1114                clientUserId, cameraId.string());
1115    }
1116
1117    return Status::ok();
1118}
1119
1120status_t CameraService::checkIfDeviceIsUsable(const String8& cameraId) const {
1121    auto cameraState = getCameraState(cameraId);
1122    int callingPid = getCallingPid();
1123    if (cameraState == nullptr) {
1124        ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
1125                cameraId.string());
1126        return -ENODEV;
1127    }
1128
1129    StatusInternal currentStatus = cameraState->getStatus();
1130    if (currentStatus == StatusInternal::NOT_PRESENT) {
1131        ALOGE("CameraService::connect X (PID %d) rejected (camera %s is not connected)",
1132                callingPid, cameraId.string());
1133        return -ENODEV;
1134    } else if (currentStatus == StatusInternal::ENUMERATING) {
1135        ALOGE("CameraService::connect X (PID %d) rejected, (camera %s is initializing)",
1136                callingPid, cameraId.string());
1137        return -EBUSY;
1138    }
1139
1140    return NO_ERROR;
1141}
1142
1143void CameraService::finishConnectLocked(const sp<BasicClient>& client,
1144        const CameraService::DescriptorPtr& desc) {
1145
1146    // Make a descriptor for the incoming client
1147    auto clientDescriptor = CameraService::CameraClientManager::makeClientDescriptor(client, desc);
1148    auto evicted = mActiveClientManager.addAndEvict(clientDescriptor);
1149
1150    logConnected(desc->getKey(), static_cast<int>(desc->getOwnerId()),
1151            String8(client->getPackageName()));
1152
1153    if (evicted.size() > 0) {
1154        // This should never happen - clients should already have been removed in disconnect
1155        for (auto& i : evicted) {
1156            ALOGE("%s: Invalid state: Client for camera %s was not removed in disconnect",
1157                    __FUNCTION__, i->getKey().string());
1158        }
1159
1160        LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, clients not evicted properly",
1161                __FUNCTION__);
1162    }
1163
1164    // And register a death notification for the client callback. Do
1165    // this last to avoid Binder policy where a nested Binder
1166    // transaction might be pre-empted to service the client death
1167    // notification if the client process dies before linkToDeath is
1168    // invoked.
1169    sp<IBinder> remoteCallback = client->getRemote();
1170    if (remoteCallback != nullptr) {
1171        remoteCallback->linkToDeath(this);
1172    }
1173}
1174
1175status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clientPid,
1176        apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
1177        /*out*/
1178        sp<BasicClient>* client,
1179        std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial) {
1180    ATRACE_CALL();
1181    status_t ret = NO_ERROR;
1182    std::vector<DescriptorPtr> evictedClients;
1183    DescriptorPtr clientDescriptor;
1184    {
1185        if (effectiveApiLevel == API_1) {
1186            // If we are using API1, any existing client for this camera ID with the same remote
1187            // should be returned rather than evicted to allow MediaRecorder to work properly.
1188
1189            auto current = mActiveClientManager.get(cameraId);
1190            if (current != nullptr) {
1191                auto clientSp = current->getValue();
1192                if (clientSp.get() != nullptr) { // should never be needed
1193                    if (!clientSp->canCastToApiClient(effectiveApiLevel)) {
1194                        ALOGW("CameraService connect called from same client, but with a different"
1195                                " API level, evicting prior client...");
1196                    } else if (clientSp->getRemote() == remoteCallback) {
1197                        ALOGI("CameraService::connect X (PID %d) (second call from same"
1198                                " app binder, returning the same client)", clientPid);
1199                        *client = clientSp;
1200                        return NO_ERROR;
1201                    }
1202                }
1203            }
1204        }
1205
1206        // Get current active client PIDs
1207        std::vector<int> ownerPids(mActiveClientManager.getAllOwners());
1208        ownerPids.push_back(clientPid);
1209
1210        std::vector<int> priorityScores(ownerPids.size());
1211        std::vector<int> states(ownerPids.size());
1212
1213        // Get priority scores of all active PIDs
1214        status_t err = ProcessInfoService::getProcessStatesScoresFromPids(
1215                ownerPids.size(), &ownerPids[0], /*out*/&states[0],
1216                /*out*/&priorityScores[0]);
1217        if (err != OK) {
1218            ALOGE("%s: Priority score query failed: %d",
1219                  __FUNCTION__, err);
1220            return err;
1221        }
1222
1223        // Update all active clients' priorities
1224        std::map<int,resource_policy::ClientPriority> pidToPriorityMap;
1225        for (size_t i = 0; i < ownerPids.size() - 1; i++) {
1226            pidToPriorityMap.emplace(ownerPids[i],
1227                    resource_policy::ClientPriority(priorityScores[i], states[i]));
1228        }
1229        mActiveClientManager.updatePriorities(pidToPriorityMap);
1230
1231        // Get state for the given cameraId
1232        auto state = getCameraState(cameraId);
1233        if (state == nullptr) {
1234            ALOGE("CameraService::connect X (PID %d) rejected (no camera device with ID %s)",
1235                clientPid, cameraId.string());
1236            // Should never get here because validateConnectLocked should have errored out
1237            return BAD_VALUE;
1238        }
1239
1240        // Make descriptor for incoming client
1241        clientDescriptor = CameraClientManager::makeClientDescriptor(cameraId,
1242                sp<BasicClient>{nullptr}, static_cast<int32_t>(state->getCost()),
1243                state->getConflicting(),
1244                priorityScores[priorityScores.size() - 1],
1245                clientPid,
1246                states[states.size() - 1]);
1247
1248        // Find clients that would be evicted
1249        auto evicted = mActiveClientManager.wouldEvict(clientDescriptor);
1250
1251        // If the incoming client was 'evicted,' higher priority clients have the camera in the
1252        // background, so we cannot do evictions
1253        if (std::find(evicted.begin(), evicted.end(), clientDescriptor) != evicted.end()) {
1254            ALOGE("CameraService::connect X (PID %d) rejected (existing client(s) with higher"
1255                    " priority).", clientPid);
1256
1257            sp<BasicClient> clientSp = clientDescriptor->getValue();
1258            String8 curTime = getFormattedCurrentTime();
1259            auto incompatibleClients =
1260                    mActiveClientManager.getIncompatibleClients(clientDescriptor);
1261
1262            String8 msg = String8::format("%s : DENIED connect device %s client for package %s "
1263                    "(PID %d, score %d state %d) due to eviction policy", curTime.string(),
1264                    cameraId.string(), packageName.string(), clientPid,
1265                    priorityScores[priorityScores.size() - 1],
1266                    states[states.size() - 1]);
1267
1268            for (auto& i : incompatibleClients) {
1269                msg.appendFormat("\n   - Blocked by existing device %s client for package %s"
1270                        "(PID %" PRId32 ", score %" PRId32 ", state %" PRId32 ")",
1271                        i->getKey().string(),
1272                        String8{i->getValue()->getPackageName()}.string(),
1273                        i->getOwnerId(), i->getPriority().getScore(),
1274                        i->getPriority().getState());
1275                ALOGE("   Conflicts with: Device %s, client package %s (PID %"
1276                        PRId32 ", score %" PRId32 ", state %" PRId32 ")", i->getKey().string(),
1277                        String8{i->getValue()->getPackageName()}.string(), i->getOwnerId(),
1278                        i->getPriority().getScore(), i->getPriority().getState());
1279            }
1280
1281            // Log the client's attempt
1282            Mutex::Autolock l(mLogLock);
1283            mEventLog.add(msg);
1284
1285            return -EBUSY;
1286        }
1287
1288        for (auto& i : evicted) {
1289            sp<BasicClient> clientSp = i->getValue();
1290            if (clientSp.get() == nullptr) {
1291                ALOGE("%s: Invalid state: Null client in active client list.", __FUNCTION__);
1292
1293                // TODO: Remove this
1294                LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, null client in active list",
1295                        __FUNCTION__);
1296                mActiveClientManager.remove(i);
1297                continue;
1298            }
1299
1300            ALOGE("CameraService::connect evicting conflicting client for camera ID %s",
1301                    i->getKey().string());
1302            evictedClients.push_back(i);
1303
1304            // Log the clients evicted
1305            logEvent(String8::format("EVICT device %s client held by package %s (PID"
1306                    " %" PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted by device %s client for"
1307                    " package %s (PID %d, score %" PRId32 ", state %" PRId32 ")",
1308                    i->getKey().string(), String8{clientSp->getPackageName()}.string(),
1309                    i->getOwnerId(), i->getPriority().getScore(),
1310                    i->getPriority().getState(), cameraId.string(),
1311                    packageName.string(), clientPid,
1312                    priorityScores[priorityScores.size() - 1],
1313                    states[states.size() - 1]));
1314
1315            // Notify the client of disconnection
1316            clientSp->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
1317                    CaptureResultExtras());
1318        }
1319    }
1320
1321    // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1322    // other clients from connecting in mServiceLockWrapper if held
1323    mServiceLock.unlock();
1324
1325    // Clear caller identity temporarily so client disconnect PID checks work correctly
1326    int64_t token = IPCThreadState::self()->clearCallingIdentity();
1327
1328    // Destroy evicted clients
1329    for (auto& i : evictedClients) {
1330        // Disconnect is blocking, and should only have returned when HAL has cleaned up
1331        i->getValue()->disconnect(); // Clients will remove themselves from the active client list
1332    }
1333
1334    IPCThreadState::self()->restoreCallingIdentity(token);
1335
1336    for (const auto& i : evictedClients) {
1337        ALOGV("%s: Waiting for disconnect to complete for client for device %s (PID %" PRId32 ")",
1338                __FUNCTION__, i->getKey().string(), i->getOwnerId());
1339        ret = mActiveClientManager.waitUntilRemoved(i, DEFAULT_DISCONNECT_TIMEOUT_NS);
1340        if (ret == TIMED_OUT) {
1341            ALOGE("%s: Timed out waiting for client for device %s to disconnect, "
1342                    "current clients:\n%s", __FUNCTION__, i->getKey().string(),
1343                    mActiveClientManager.toString().string());
1344            return -EBUSY;
1345        }
1346        if (ret != NO_ERROR) {
1347            ALOGE("%s: Received error waiting for client for device %s to disconnect: %s (%d), "
1348                    "current clients:\n%s", __FUNCTION__, i->getKey().string(), strerror(-ret),
1349                    ret, mActiveClientManager.toString().string());
1350            return ret;
1351        }
1352    }
1353
1354    evictedClients.clear();
1355
1356    // Once clients have been disconnected, relock
1357    mServiceLock.lock();
1358
1359    // Check again if the device was unplugged or something while we weren't holding mServiceLock
1360    if ((ret = checkIfDeviceIsUsable(cameraId)) != NO_ERROR) {
1361        return ret;
1362    }
1363
1364    *partial = clientDescriptor;
1365    return NO_ERROR;
1366}
1367
1368Status CameraService::connect(
1369        const sp<ICameraClient>& cameraClient,
1370        int cameraId,
1371        const String16& clientPackageName,
1372        int clientUid,
1373        int clientPid,
1374        /*out*/
1375        sp<ICamera>* device) {
1376
1377    ATRACE_CALL();
1378    Status ret = Status::ok();
1379    String8 id = String8::format("%d", cameraId);
1380    sp<Client> client = nullptr;
1381    ret = connectHelper<ICameraClient,Client>(cameraClient, id,
1382            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
1383            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
1384            /*out*/client);
1385
1386    if(!ret.isOk()) {
1387        logRejected(id, getCallingPid(), String8(clientPackageName),
1388                ret.toString8());
1389        return ret;
1390    }
1391
1392    *device = client;
1393    return ret;
1394}
1395
1396Status CameraService::connectLegacy(
1397        const sp<ICameraClient>& cameraClient,
1398        int cameraId, int halVersion,
1399        const String16& clientPackageName,
1400        int clientUid,
1401        /*out*/
1402        sp<ICamera>* device) {
1403
1404    ATRACE_CALL();
1405    String8 id = String8::format("%d", cameraId);
1406    if (mModule != nullptr) {
1407        int apiVersion = mModule->getModuleApiVersion();
1408        if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED &&
1409                apiVersion < CAMERA_MODULE_API_VERSION_2_3) {
1410            /*
1411             * Either the HAL version is unspecified in which case this just creates
1412             * a camera client selected by the latest device version, or
1413             * it's a particular version in which case the HAL must supported
1414             * the open_legacy call
1415             */
1416            String8 msg = String8::format("Camera HAL module version %x too old for connectLegacy!",
1417                    apiVersion);
1418            ALOGE("%s: %s",
1419                    __FUNCTION__, msg.string());
1420            logRejected(id, getCallingPid(), String8(clientPackageName),
1421                    msg);
1422            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1423        }
1424    }
1425
1426    Status ret = Status::ok();
1427    sp<Client> client = nullptr;
1428    ret = connectHelper<ICameraClient,Client>(cameraClient, id, halVersion,
1429            clientPackageName, clientUid, USE_CALLING_PID, API_1,
1430            /*legacyMode*/ true, /*shimUpdateOnly*/ false,
1431            /*out*/client);
1432
1433    if(!ret.isOk()) {
1434        logRejected(id, getCallingPid(), String8(clientPackageName),
1435                ret.toString8());
1436        return ret;
1437    }
1438
1439    *device = client;
1440    return ret;
1441}
1442
1443Status CameraService::connectDevice(
1444        const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
1445        const String16& cameraId,
1446        const String16& clientPackageName,
1447        int clientUid,
1448        /*out*/
1449        sp<hardware::camera2::ICameraDeviceUser>* device) {
1450
1451    ATRACE_CALL();
1452    Status ret = Status::ok();
1453    String8 id = String8(cameraId);
1454    sp<CameraDeviceClient> client = nullptr;
1455    ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
1456            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
1457            clientUid, USE_CALLING_PID, API_2,
1458            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
1459            /*out*/client);
1460
1461    if(!ret.isOk()) {
1462        logRejected(id, getCallingPid(), String8(clientPackageName),
1463                ret.toString8());
1464        return ret;
1465    }
1466
1467    *device = client;
1468    return ret;
1469}
1470
1471template<class CALLBACK, class CLIENT>
1472Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
1473        int halVersion, const String16& clientPackageName, int clientUid, int clientPid,
1474        apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
1475        /*out*/sp<CLIENT>& device) {
1476    binder::Status ret = binder::Status::ok();
1477
1478    String8 clientName8(clientPackageName);
1479
1480    int originalClientPid = 0;
1481
1482    ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
1483            "Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
1484            (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
1485            static_cast<int>(effectiveApiLevel));
1486
1487    sp<CLIENT> client = nullptr;
1488    {
1489        // Acquire mServiceLock and prevent other clients from connecting
1490        std::unique_ptr<AutoConditionLock> lock =
1491                AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
1492
1493        if (lock == nullptr) {
1494            ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
1495                    , clientPid);
1496            return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1497                    "Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
1498                    cameraId.string(), clientName8.string(), clientPid);
1499        }
1500
1501        // Enforce client permissions and do basic sanity checks
1502        if(!(ret = validateConnectLocked(cameraId, clientName8,
1503                /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
1504            return ret;
1505        }
1506
1507        // Check the shim parameters after acquiring lock, if they have already been updated and
1508        // we were doing a shim update, return immediately
1509        if (shimUpdateOnly) {
1510            auto cameraState = getCameraState(cameraId);
1511            if (cameraState != nullptr) {
1512                if (!cameraState->getShimParams().isEmpty()) return ret;
1513            }
1514        }
1515
1516        status_t err;
1517
1518        sp<BasicClient> clientTmp = nullptr;
1519        std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
1520        if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
1521                IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
1522                /*out*/&partial)) != NO_ERROR) {
1523            switch (err) {
1524                case -ENODEV:
1525                    return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1526                            "No camera device with ID \"%s\" currently available",
1527                            cameraId.string());
1528                case -EBUSY:
1529                    return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1530                            "Higher-priority client using camera, ID \"%s\" currently unavailable",
1531                            cameraId.string());
1532                default:
1533                    return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1534                            "Unexpected error %s (%d) opening camera \"%s\"",
1535                            strerror(-err), err, cameraId.string());
1536            }
1537        }
1538
1539        if (clientTmp.get() != nullptr) {
1540            // Handle special case for API1 MediaRecorder where the existing client is returned
1541            device = static_cast<CLIENT*>(clientTmp.get());
1542            return ret;
1543        }
1544
1545        // give flashlight a chance to close devices if necessary.
1546        mFlashlight->prepareDeviceOpen(cameraId);
1547
1548        int facing = -1;
1549        int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
1550        if (facing == -1) {
1551            ALOGE("%s: Unable to get camera device \"%s\"  facing", __FUNCTION__, cameraId.string());
1552            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1553                    "Unable to get camera device \"%s\" facing", cameraId.string());
1554        }
1555
1556        sp<BasicClient> tmp = nullptr;
1557        if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
1558                clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
1559                /*out*/&tmp)).isOk()) {
1560            return ret;
1561        }
1562        client = static_cast<CLIENT*>(tmp.get());
1563
1564        LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
1565                __FUNCTION__);
1566
1567        if (mModule != nullptr) {
1568            err = client->initialize(mModule);
1569        } else {
1570            err = client->initialize(mCameraProviderManager);
1571        }
1572
1573        if (err != OK) {
1574            ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
1575            // Errors could be from the HAL module open call or from AppOpsManager
1576            switch(err) {
1577                case BAD_VALUE:
1578                    return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1579                            "Illegal argument to HAL module for camera \"%s\"", cameraId.string());
1580                case -EBUSY:
1581                    return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1582                            "Camera \"%s\" is already open", cameraId.string());
1583                case -EUSERS:
1584                    return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1585                            "Too many cameras already open, cannot open camera \"%s\"",
1586                            cameraId.string());
1587                case PERMISSION_DENIED:
1588                    return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1589                            "No permission to open camera \"%s\"", cameraId.string());
1590                case -EACCES:
1591                    return STATUS_ERROR_FMT(ERROR_DISABLED,
1592                            "Camera \"%s\" disabled by policy", cameraId.string());
1593                case -ENODEV:
1594                default:
1595                    return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1596                            "Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
1597                            strerror(-err), err);
1598            }
1599        }
1600
1601        // Update shim paremeters for legacy clients
1602        if (effectiveApiLevel == API_1) {
1603            // Assume we have always received a Client subclass for API1
1604            sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
1605            String8 rawParams = shimClient->getParameters();
1606            CameraParameters params(rawParams);
1607
1608            auto cameraState = getCameraState(cameraId);
1609            if (cameraState != nullptr) {
1610                cameraState->setShimParams(params);
1611            } else {
1612                ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
1613                        __FUNCTION__, cameraId.string());
1614            }
1615        }
1616
1617        if (shimUpdateOnly) {
1618            // If only updating legacy shim parameters, immediately disconnect client
1619            mServiceLock.unlock();
1620            client->disconnect();
1621            mServiceLock.lock();
1622        } else {
1623            // Otherwise, add client to active clients list
1624            finishConnectLocked(client, partial);
1625        }
1626    } // lock is destroyed, allow further connect calls
1627
1628    // Important: release the mutex here so the client can call back into the service from its
1629    // destructor (can be at the end of the call)
1630    device = client;
1631    return ret;
1632}
1633
1634Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
1635        const sp<IBinder>& clientBinder) {
1636    Mutex::Autolock lock(mServiceLock);
1637
1638    ATRACE_CALL();
1639    if (enabled && clientBinder == nullptr) {
1640        ALOGE("%s: torch client binder is NULL", __FUNCTION__);
1641        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
1642                "Torch client Binder is null");
1643    }
1644
1645    String8 id = String8(cameraId.string());
1646    int uid = getCallingUid();
1647
1648    // verify id is valid.
1649    auto state = getCameraState(id);
1650    if (state == nullptr) {
1651        ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string());
1652        return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1653                "Camera ID \"%s\" is a not valid camera ID", id.string());
1654    }
1655
1656    StatusInternal cameraStatus = state->getStatus();
1657    if (cameraStatus != StatusInternal::PRESENT &&
1658            cameraStatus != StatusInternal::NOT_AVAILABLE) {
1659        ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus);
1660        return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1661                "Camera ID \"%s\" is a not valid camera ID", id.string());
1662    }
1663
1664    {
1665        Mutex::Autolock al(mTorchStatusMutex);
1666        TorchModeStatus status;
1667        status_t err = getTorchStatusLocked(id, &status);
1668        if (err != OK) {
1669            if (err == NAME_NOT_FOUND) {
1670                return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1671                        "Camera \"%s\" does not have a flash unit", id.string());
1672            }
1673            ALOGE("%s: getting current torch status failed for camera %s",
1674                    __FUNCTION__, id.string());
1675            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1676                    "Error updating torch status for camera \"%s\": %s (%d)", id.string(),
1677                    strerror(-err), err);
1678        }
1679
1680        if (status == TorchModeStatus::NOT_AVAILABLE) {
1681            if (cameraStatus == StatusInternal::NOT_AVAILABLE) {
1682                ALOGE("%s: torch mode of camera %s is not available because "
1683                        "camera is in use", __FUNCTION__, id.string());
1684                return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1685                        "Torch for camera \"%s\" is not available due to an existing camera user",
1686                        id.string());
1687            } else {
1688                ALOGE("%s: torch mode of camera %s is not available due to "
1689                        "insufficient resources", __FUNCTION__, id.string());
1690                return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1691                        "Torch for camera \"%s\" is not available due to insufficient resources",
1692                        id.string());
1693            }
1694        }
1695    }
1696
1697    {
1698        // Update UID map - this is used in the torch status changed callbacks, so must be done
1699        // before setTorchMode
1700        Mutex::Autolock al(mTorchUidMapMutex);
1701        if (mTorchUidMap.find(id) == mTorchUidMap.end()) {
1702            mTorchUidMap[id].first = uid;
1703            mTorchUidMap[id].second = uid;
1704        } else {
1705            // Set the pending UID
1706            mTorchUidMap[id].first = uid;
1707        }
1708    }
1709
1710    status_t err = mFlashlight->setTorchMode(id, enabled);
1711
1712    if (err != OK) {
1713        int32_t errorCode;
1714        String8 msg;
1715        switch (err) {
1716            case -ENOSYS:
1717                msg = String8::format("Camera \"%s\" has no flashlight",
1718                    id.string());
1719                errorCode = ERROR_ILLEGAL_ARGUMENT;
1720                break;
1721            default:
1722                msg = String8::format(
1723                    "Setting torch mode of camera \"%s\" to %d failed: %s (%d)",
1724                    id.string(), enabled, strerror(-err), err);
1725                errorCode = ERROR_INVALID_OPERATION;
1726        }
1727        ALOGE("%s: %s", __FUNCTION__, msg.string());
1728        return STATUS_ERROR(errorCode, msg.string());
1729    }
1730
1731    {
1732        // update the link to client's death
1733        Mutex::Autolock al(mTorchClientMapMutex);
1734        ssize_t index = mTorchClientMap.indexOfKey(id);
1735        if (enabled) {
1736            if (index == NAME_NOT_FOUND) {
1737                mTorchClientMap.add(id, clientBinder);
1738            } else {
1739                mTorchClientMap.valueAt(index)->unlinkToDeath(this);
1740                mTorchClientMap.replaceValueAt(index, clientBinder);
1741            }
1742            clientBinder->linkToDeath(this);
1743        } else if (index != NAME_NOT_FOUND) {
1744            mTorchClientMap.valueAt(index)->unlinkToDeath(this);
1745        }
1746    }
1747
1748    return Status::ok();
1749}
1750
1751Status CameraService::notifySystemEvent(int32_t eventId,
1752        const std::vector<int32_t>& args) {
1753    ATRACE_CALL();
1754
1755    switch(eventId) {
1756        case ICameraService::EVENT_USER_SWITCHED: {
1757            doUserSwitch(/*newUserIds*/ args);
1758            break;
1759        }
1760        case ICameraService::EVENT_NONE:
1761        default: {
1762            ALOGW("%s: Received invalid system event from system_server: %d", __FUNCTION__,
1763                    eventId);
1764            break;
1765        }
1766    }
1767    return Status::ok();
1768}
1769
1770Status CameraService::addListener(const sp<ICameraServiceListener>& listener,
1771        /*out*/
1772        std::vector<hardware::CameraStatus> *cameraStatuses) {
1773    ATRACE_CALL();
1774
1775    ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
1776
1777    if (listener == nullptr) {
1778        ALOGE("%s: Listener must not be null", __FUNCTION__);
1779        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to addListener");
1780    }
1781
1782    Mutex::Autolock lock(mServiceLock);
1783
1784    {
1785        Mutex::Autolock lock(mStatusListenerLock);
1786        for (auto& it : mListenerList) {
1787            if (IInterface::asBinder(it) == IInterface::asBinder(listener)) {
1788                ALOGW("%s: Tried to add listener %p which was already subscribed",
1789                      __FUNCTION__, listener.get());
1790                return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
1791            }
1792        }
1793
1794        mListenerList.push_back(listener);
1795    }
1796
1797    /* Collect current devices and status */
1798    {
1799        Mutex::Autolock lock(mCameraStatesLock);
1800        for (auto& i : mCameraStates) {
1801            cameraStatuses->emplace_back(i.first, mapToInterface(i.second->getStatus()));
1802        }
1803    }
1804
1805    /*
1806     * Immediately signal current torch status to this listener only
1807     * This may be a subset of all the devices, so don't include it in the response directly
1808     */
1809    {
1810        Mutex::Autolock al(mTorchStatusMutex);
1811        for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) {
1812            String16 id = String16(mTorchStatusMap.keyAt(i).string());
1813            listener->onTorchStatusChanged(mapToInterface(mTorchStatusMap.valueAt(i)), id);
1814        }
1815    }
1816
1817    return Status::ok();
1818}
1819
1820Status CameraService::removeListener(const sp<ICameraServiceListener>& listener) {
1821    ATRACE_CALL();
1822
1823    ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
1824
1825    if (listener == 0) {
1826        ALOGE("%s: Listener must not be null", __FUNCTION__);
1827        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to removeListener");
1828    }
1829
1830    Mutex::Autolock lock(mServiceLock);
1831
1832    {
1833        Mutex::Autolock lock(mStatusListenerLock);
1834        for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) {
1835            if (IInterface::asBinder(*it) == IInterface::asBinder(listener)) {
1836                mListenerList.erase(it);
1837                return Status::ok();
1838            }
1839        }
1840    }
1841
1842    ALOGW("%s: Tried to remove a listener %p which was not subscribed",
1843          __FUNCTION__, listener.get());
1844
1845    return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Unregistered listener given to removeListener");
1846}
1847
1848Status CameraService::getLegacyParameters(int cameraId, /*out*/String16* parameters) {
1849
1850    ATRACE_CALL();
1851    ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1852
1853    if (parameters == NULL) {
1854        ALOGE("%s: parameters must not be null", __FUNCTION__);
1855        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
1856    }
1857
1858    Status ret = Status::ok();
1859
1860    CameraParameters shimParams;
1861    if (!(ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)).isOk()) {
1862        // Error logged by caller
1863        return ret;
1864    }
1865
1866    String8 shimParamsString8 = shimParams.flatten();
1867    String16 shimParamsString16 = String16(shimParamsString8);
1868
1869    *parameters = shimParamsString16;
1870
1871    return ret;
1872}
1873
1874Status CameraService::supportsCameraApi(const String16& cameraId, int apiVersion,
1875        /*out*/ bool *isSupported) {
1876    ATRACE_CALL();
1877
1878    const String8 id = String8(cameraId);
1879
1880    ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
1881
1882    switch (apiVersion) {
1883        case API_VERSION_1:
1884        case API_VERSION_2:
1885            break;
1886        default:
1887            String8 msg = String8::format("Unknown API version %d", apiVersion);
1888            ALOGE("%s: %s", __FUNCTION__, msg.string());
1889            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1890    }
1891
1892    int deviceVersion = getDeviceVersion(id);
1893    switch(deviceVersion) {
1894        case CAMERA_DEVICE_API_VERSION_1_0:
1895        case CAMERA_DEVICE_API_VERSION_3_0:
1896        case CAMERA_DEVICE_API_VERSION_3_1:
1897            if (apiVersion == API_VERSION_2) {
1898                ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim",
1899                        __FUNCTION__, id.string(), deviceVersion);
1900                *isSupported = false;
1901            } else { // if (apiVersion == API_VERSION_1) {
1902                ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported",
1903                        __FUNCTION__, id.string());
1904                *isSupported = true;
1905            }
1906            break;
1907        case CAMERA_DEVICE_API_VERSION_3_2:
1908        case CAMERA_DEVICE_API_VERSION_3_3:
1909        case CAMERA_DEVICE_API_VERSION_3_4:
1910            ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
1911                    __FUNCTION__, id.string());
1912            *isSupported = true;
1913            break;
1914        case -1: {
1915            String8 msg = String8::format("Unknown camera ID %s", id.string());
1916            ALOGE("%s: %s", __FUNCTION__, msg.string());
1917            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1918        }
1919        default: {
1920            String8 msg = String8::format("Unknown device version %x for device %s",
1921                    deviceVersion, id.string());
1922            ALOGE("%s: %s", __FUNCTION__, msg.string());
1923            return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
1924        }
1925    }
1926
1927    return Status::ok();
1928}
1929
1930void CameraService::removeByClient(const BasicClient* client) {
1931    Mutex::Autolock lock(mServiceLock);
1932    for (auto& i : mActiveClientManager.getAll()) {
1933        auto clientSp = i->getValue();
1934        if (clientSp.get() == client) {
1935            mActiveClientManager.remove(i);
1936        }
1937    }
1938}
1939
1940bool CameraService::evictClientIdByRemote(const wp<IBinder>& remote) {
1941    const int callingPid = getCallingPid();
1942    const int servicePid = getpid();
1943    bool ret = false;
1944    {
1945        // Acquire mServiceLock and prevent other clients from connecting
1946        std::unique_ptr<AutoConditionLock> lock =
1947                AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
1948
1949
1950        std::vector<sp<BasicClient>> evicted;
1951        for (auto& i : mActiveClientManager.getAll()) {
1952            auto clientSp = i->getValue();
1953            if (clientSp.get() == nullptr) {
1954                ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
1955                mActiveClientManager.remove(i);
1956                continue;
1957            }
1958            if (remote == clientSp->getRemote() && (callingPid == servicePid ||
1959                    callingPid == clientSp->getClientPid())) {
1960                mActiveClientManager.remove(i);
1961                evicted.push_back(clientSp);
1962
1963                // Notify the client of disconnection
1964                clientSp->notifyError(
1965                        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
1966                        CaptureResultExtras());
1967            }
1968        }
1969
1970        // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1971        // other clients from connecting in mServiceLockWrapper if held
1972        mServiceLock.unlock();
1973
1974        // Do not clear caller identity, remote caller should be client proccess
1975
1976        for (auto& i : evicted) {
1977            if (i.get() != nullptr) {
1978                i->disconnect();
1979                ret = true;
1980            }
1981        }
1982
1983        // Reacquire mServiceLock
1984        mServiceLock.lock();
1985
1986    } // lock is destroyed, allow further connect calls
1987
1988    return ret;
1989}
1990
1991
1992/**
1993 * Check camera capabilities, such as support for basic color operation
1994 * Also check that the device HAL version is still in support
1995 */
1996int CameraService::checkCameraCapabilities(int id, camera_info info, int *latestStrangeCameraId) {
1997    if (mModule == nullptr) return NO_INIT;
1998
1999    // device_version undefined in CAMERA_MODULE_API_VERSION_1_0,
2000    // All CAMERA_MODULE_API_VERSION_1_0 devices are backward-compatible
2001    if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
2002        // Verify the device version is in the supported range
2003        switch (info.device_version) {
2004            case CAMERA_DEVICE_API_VERSION_1_0:
2005            case CAMERA_DEVICE_API_VERSION_3_0:
2006            case CAMERA_DEVICE_API_VERSION_3_1:
2007            case CAMERA_DEVICE_API_VERSION_3_2:
2008            case CAMERA_DEVICE_API_VERSION_3_3:
2009            case CAMERA_DEVICE_API_VERSION_3_4:
2010                // in support
2011                break;
2012            case CAMERA_DEVICE_API_VERSION_2_0:
2013            case CAMERA_DEVICE_API_VERSION_2_1:
2014                // no longer supported
2015            default:
2016                ALOGE("%s: Device %d has HAL version %x, which is not supported",
2017                        __FUNCTION__, id, info.device_version);
2018                String8 msg = String8::format(
2019                        "Unsupported device HAL version %x for device %d",
2020                        info.device_version, id);
2021                logServiceError(msg.string(), NO_INIT);
2022                return NO_INIT;
2023        }
2024    }
2025
2026    // Assume all devices pre-v3.3 are backward-compatible
2027    bool isBackwardCompatible = true;
2028    if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0
2029            && info.device_version >= CAMERA_DEVICE_API_VERSION_3_3) {
2030        isBackwardCompatible = false;
2031        status_t res;
2032        camera_metadata_ro_entry_t caps;
2033        res = find_camera_metadata_ro_entry(
2034            info.static_camera_characteristics,
2035            ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
2036            &caps);
2037        if (res != 0) {
2038            ALOGW("%s: Unable to find camera capabilities for camera device %d",
2039                    __FUNCTION__, id);
2040            caps.count = 0;
2041        }
2042        for (size_t i = 0; i < caps.count; i++) {
2043            if (caps.data.u8[i] ==
2044                    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2045                isBackwardCompatible = true;
2046                break;
2047            }
2048        }
2049    }
2050
2051    if (!isBackwardCompatible) {
2052        mNumberOfNormalCameras--;
2053        *latestStrangeCameraId = id;
2054    } else {
2055        if (id > *latestStrangeCameraId) {
2056            ALOGE("%s: Normal camera ID %d higher than strange camera ID %d. "
2057                    "This is not allowed due backward-compatibility requirements",
2058                    __FUNCTION__, id, *latestStrangeCameraId);
2059            logServiceError("Invalid order of camera devices", NO_INIT);
2060            mNumberOfCameras = 0;
2061            mNumberOfNormalCameras = 0;
2062            return NO_INIT;
2063        }
2064    }
2065    return OK;
2066}
2067
2068std::shared_ptr<CameraService::CameraState> CameraService::getCameraState(
2069        const String8& cameraId) const {
2070    std::shared_ptr<CameraState> state;
2071    {
2072        Mutex::Autolock lock(mCameraStatesLock);
2073        auto iter = mCameraStates.find(cameraId);
2074        if (iter != mCameraStates.end()) {
2075            state = iter->second;
2076        }
2077    }
2078    return state;
2079}
2080
2081sp<CameraService::BasicClient> CameraService::removeClientLocked(const String8& cameraId) {
2082    // Remove from active clients list
2083    auto clientDescriptorPtr = mActiveClientManager.remove(cameraId);
2084    if (clientDescriptorPtr == nullptr) {
2085        ALOGW("%s: Could not evict client, no client for camera ID %s", __FUNCTION__,
2086                cameraId.string());
2087        return sp<BasicClient>{nullptr};
2088    }
2089
2090    return clientDescriptorPtr->getValue();
2091}
2092
2093void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) {
2094    // Acquire mServiceLock and prevent other clients from connecting
2095    std::unique_ptr<AutoConditionLock> lock =
2096            AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
2097
2098    std::set<userid_t> newAllowedUsers;
2099    for (size_t i = 0; i < newUserIds.size(); i++) {
2100        if (newUserIds[i] < 0) {
2101            ALOGE("%s: Bad user ID %d given during user switch, ignoring.",
2102                    __FUNCTION__, newUserIds[i]);
2103            return;
2104        }
2105        newAllowedUsers.insert(static_cast<userid_t>(newUserIds[i]));
2106    }
2107
2108
2109    if (newAllowedUsers == mAllowedUsers) {
2110        ALOGW("%s: Received notification of user switch with no updated user IDs.", __FUNCTION__);
2111        return;
2112    }
2113
2114    logUserSwitch(mAllowedUsers, newAllowedUsers);
2115
2116    mAllowedUsers = std::move(newAllowedUsers);
2117
2118    // Current user has switched, evict all current clients.
2119    std::vector<sp<BasicClient>> evicted;
2120    for (auto& i : mActiveClientManager.getAll()) {
2121        auto clientSp = i->getValue();
2122
2123        if (clientSp.get() == nullptr) {
2124            ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
2125            continue;
2126        }
2127
2128        // Don't evict clients that are still allowed.
2129        uid_t clientUid = clientSp->getClientUid();
2130        userid_t clientUserId = multiuser_get_user_id(clientUid);
2131        if (mAllowedUsers.find(clientUserId) != mAllowedUsers.end()) {
2132            continue;
2133        }
2134
2135        evicted.push_back(clientSp);
2136
2137        String8 curTime = getFormattedCurrentTime();
2138
2139        ALOGE("Evicting conflicting client for camera ID %s due to user change",
2140                i->getKey().string());
2141
2142        // Log the clients evicted
2143        logEvent(String8::format("EVICT device %s client held by package %s (PID %"
2144                PRId32 ", score %" PRId32 ", state %" PRId32 ")\n   - Evicted due"
2145                " to user switch.", i->getKey().string(),
2146                String8{clientSp->getPackageName()}.string(),
2147                i->getOwnerId(), i->getPriority().getScore(),
2148                i->getPriority().getState()));
2149
2150    }
2151
2152    // Do not hold mServiceLock while disconnecting clients, but retain the condition
2153    // blocking other clients from connecting in mServiceLockWrapper if held.
2154    mServiceLock.unlock();
2155
2156    // Clear caller identity temporarily so client disconnect PID checks work correctly
2157    int64_t token = IPCThreadState::self()->clearCallingIdentity();
2158
2159    for (auto& i : evicted) {
2160        i->disconnect();
2161    }
2162
2163    IPCThreadState::self()->restoreCallingIdentity(token);
2164
2165    // Reacquire mServiceLock
2166    mServiceLock.lock();
2167}
2168
2169void CameraService::logEvent(const char* event) {
2170    String8 curTime = getFormattedCurrentTime();
2171    Mutex::Autolock l(mLogLock);
2172    mEventLog.add(String8::format("%s : %s", curTime.string(), event));
2173}
2174
2175void CameraService::logDisconnected(const char* cameraId, int clientPid,
2176        const char* clientPackage) {
2177    // Log the clients evicted
2178    logEvent(String8::format("DISCONNECT device %s client for package %s (PID %d)", cameraId,
2179            clientPackage, clientPid));
2180}
2181
2182void CameraService::logConnected(const char* cameraId, int clientPid,
2183        const char* clientPackage) {
2184    // Log the clients evicted
2185    logEvent(String8::format("CONNECT device %s client for package %s (PID %d)", cameraId,
2186            clientPackage, clientPid));
2187}
2188
2189void CameraService::logRejected(const char* cameraId, int clientPid,
2190        const char* clientPackage, const char* reason) {
2191    // Log the client rejected
2192    logEvent(String8::format("REJECT device %s client for package %s (PID %d), reason: (%s)",
2193            cameraId, clientPackage, clientPid, reason));
2194}
2195
2196void CameraService::logUserSwitch(const std::set<userid_t>& oldUserIds,
2197        const std::set<userid_t>& newUserIds) {
2198    String8 newUsers = toString(newUserIds);
2199    String8 oldUsers = toString(oldUserIds);
2200    if (oldUsers.size() == 0) {
2201        oldUsers = "<None>";
2202    }
2203    // Log the new and old users
2204    logEvent(String8::format("USER_SWITCH previous allowed user IDs: %s, current allowed user IDs: %s",
2205            oldUsers.string(), newUsers.string()));
2206}
2207
2208void CameraService::logDeviceRemoved(const char* cameraId, const char* reason) {
2209    // Log the device removal
2210    logEvent(String8::format("REMOVE device %s, reason: (%s)", cameraId, reason));
2211}
2212
2213void CameraService::logDeviceAdded(const char* cameraId, const char* reason) {
2214    // Log the device removal
2215    logEvent(String8::format("ADD device %s, reason: (%s)", cameraId, reason));
2216}
2217
2218void CameraService::logClientDied(int clientPid, const char* reason) {
2219    // Log the device removal
2220    logEvent(String8::format("DIED client(s) with PID %d, reason: (%s)", clientPid, reason));
2221}
2222
2223void CameraService::logServiceError(const char* msg, int errorCode) {
2224    String8 curTime = getFormattedCurrentTime();
2225    logEvent(String8::format("SERVICE ERROR: %s : %d (%s)", msg, errorCode, strerror(-errorCode)));
2226}
2227
2228status_t CameraService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
2229        uint32_t flags) {
2230
2231    const int pid = getCallingPid();
2232    const int selfPid = getpid();
2233
2234    // Permission checks
2235    switch (code) {
2236        case BnCameraService::NOTIFYSYSTEMEVENT: {
2237            if (pid != selfPid) {
2238                // Ensure we're being called by system_server, or similar process with
2239                // permissions to notify the camera service about system events
2240                if (!checkCallingPermission(
2241                        String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) {
2242                    const int uid = getCallingUid();
2243                    ALOGE("Permission Denial: cannot send updates to camera service about system"
2244                            " events from pid=%d, uid=%d", pid, uid);
2245                    return PERMISSION_DENIED;
2246                }
2247            }
2248            break;
2249        }
2250    }
2251
2252    return BnCameraService::onTransact(code, data, reply, flags);
2253}
2254
2255// We share the media players for shutter and recording sound for all clients.
2256// A reference count is kept to determine when we will actually release the
2257// media players.
2258
2259MediaPlayer* CameraService::newMediaPlayer(const char *file) {
2260    MediaPlayer* mp = new MediaPlayer();
2261    if (mp->setDataSource(NULL /* httpService */, file, NULL) == NO_ERROR) {
2262        mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
2263        mp->prepare();
2264    } else {
2265        ALOGE("Failed to load CameraService sounds: %s", file);
2266        return NULL;
2267    }
2268    return mp;
2269}
2270
2271void CameraService::loadSound() {
2272    ATRACE_CALL();
2273
2274    Mutex::Autolock lock(mSoundLock);
2275    LOG1("CameraService::loadSound ref=%d", mSoundRef);
2276    if (mSoundRef++) return;
2277
2278    mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
2279    mSoundPlayer[SOUND_RECORDING_START] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
2280    mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/system/media/audio/ui/VideoStop.ogg");
2281}
2282
2283void CameraService::releaseSound() {
2284    Mutex::Autolock lock(mSoundLock);
2285    LOG1("CameraService::releaseSound ref=%d", mSoundRef);
2286    if (--mSoundRef) return;
2287
2288    for (int i = 0; i < NUM_SOUNDS; i++) {
2289        if (mSoundPlayer[i] != 0) {
2290            mSoundPlayer[i]->disconnect();
2291            mSoundPlayer[i].clear();
2292        }
2293    }
2294}
2295
2296void CameraService::playSound(sound_kind kind) {
2297    ATRACE_CALL();
2298
2299    LOG1("playSound(%d)", kind);
2300    Mutex::Autolock lock(mSoundLock);
2301    sp<MediaPlayer> player = mSoundPlayer[kind];
2302    if (player != 0) {
2303        player->seekTo(0);
2304        player->start();
2305    }
2306}
2307
2308// ----------------------------------------------------------------------------
2309
2310CameraService::Client::Client(const sp<CameraService>& cameraService,
2311        const sp<ICameraClient>& cameraClient,
2312        const String16& clientPackageName,
2313        const String8& cameraIdStr, int cameraFacing,
2314        int clientPid, uid_t clientUid,
2315        int servicePid) :
2316        CameraService::BasicClient(cameraService,
2317                IInterface::asBinder(cameraClient),
2318                clientPackageName,
2319                cameraIdStr, cameraFacing,
2320                clientPid, clientUid,
2321                servicePid),
2322        mCameraId(CameraService::cameraIdToInt(cameraIdStr))
2323{
2324    int callingPid = getCallingPid();
2325    LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
2326
2327    mRemoteCallback = cameraClient;
2328
2329    cameraService->loadSound();
2330
2331    LOG1("Client::Client X (pid %d, id %d)", callingPid, mCameraId);
2332}
2333
2334// tear down the client
2335CameraService::Client::~Client() {
2336    ALOGV("~Client");
2337    mDestructionStarted = true;
2338
2339    sCameraService->releaseSound();
2340    // unconditionally disconnect. function is idempotent
2341    Client::disconnect();
2342}
2343
2344sp<CameraService> CameraService::BasicClient::BasicClient::sCameraService;
2345
2346CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
2347        const sp<IBinder>& remoteCallback,
2348        const String16& clientPackageName,
2349        const String8& cameraIdStr, int cameraFacing,
2350        int clientPid, uid_t clientUid,
2351        int servicePid):
2352        mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing),
2353        mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid),
2354        mServicePid(servicePid),
2355        mDisconnected(false),
2356        mRemoteBinder(remoteCallback)
2357{
2358    if (sCameraService == nullptr) {
2359        sCameraService = cameraService;
2360    }
2361    mOpsActive = false;
2362    mDestructionStarted = false;
2363
2364    // In some cases the calling code has no access to the package it runs under.
2365    // For example, NDK camera API.
2366    // In this case we will get the packages for the calling UID and pick the first one
2367    // for attributing the app op. This will work correctly for runtime permissions
2368    // as for legacy apps we will toggle the app op for all packages in the UID.
2369    // The caveat is that the operation may be attributed to the wrong package and
2370    // stats based on app ops may be slightly off.
2371    if (mClientPackageName.size() <= 0) {
2372        sp<IServiceManager> sm = defaultServiceManager();
2373        sp<IBinder> binder = sm->getService(String16(kPermissionServiceName));
2374        if (binder == 0) {
2375            ALOGE("Cannot get permission service");
2376            // Leave mClientPackageName unchanged (empty) and the further interaction
2377            // with camera will fail in BasicClient::startCameraOps
2378            return;
2379        }
2380
2381        sp<IPermissionController> permCtrl = interface_cast<IPermissionController>(binder);
2382        Vector<String16> packages;
2383
2384        permCtrl->getPackagesForUid(mClientUid, packages);
2385
2386        if (packages.isEmpty()) {
2387            ALOGE("No packages for calling UID");
2388            // Leave mClientPackageName unchanged (empty) and the further interaction
2389            // with camera will fail in BasicClient::startCameraOps
2390            return;
2391        }
2392        mClientPackageName = packages[0];
2393    }
2394}
2395
2396CameraService::BasicClient::~BasicClient() {
2397    ALOGV("~BasicClient");
2398    mDestructionStarted = true;
2399}
2400
2401binder::Status CameraService::BasicClient::disconnect() {
2402    binder::Status res = Status::ok();
2403    if (mDisconnected) {
2404        return res;
2405    }
2406    mDisconnected = true;
2407
2408    sCameraService->removeByClient(this);
2409    sCameraService->logDisconnected(mCameraIdStr, mClientPid,
2410            String8(mClientPackageName));
2411
2412    sp<IBinder> remote = getRemote();
2413    if (remote != nullptr) {
2414        remote->unlinkToDeath(sCameraService);
2415    }
2416
2417    finishCameraOps();
2418    // Notify flashlight that a camera device is closed.
2419    sCameraService->mFlashlight->deviceClosed(mCameraIdStr);
2420    ALOGI("%s: Disconnected client for camera %s for PID %d", __FUNCTION__, mCameraIdStr.string(),
2421            mClientPid);
2422
2423    // client shouldn't be able to call into us anymore
2424    mClientPid = 0;
2425
2426    return res;
2427}
2428
2429status_t CameraService::BasicClient::dump(int, const Vector<String16>&) {
2430    // No dumping of clients directly over Binder,
2431    // must go through CameraService::dump
2432    android_errorWriteWithInfoLog(SN_EVENT_LOG_ID, "26265403",
2433            IPCThreadState::self()->getCallingUid(), NULL, 0);
2434    return OK;
2435}
2436
2437String16 CameraService::BasicClient::getPackageName() const {
2438    return mClientPackageName;
2439}
2440
2441
2442int CameraService::BasicClient::getClientPid() const {
2443    return mClientPid;
2444}
2445
2446uid_t CameraService::BasicClient::getClientUid() const {
2447    return mClientUid;
2448}
2449
2450bool CameraService::BasicClient::canCastToApiClient(apiLevel level) const {
2451    // Defaults to API2.
2452    return level == API_2;
2453}
2454
2455status_t CameraService::BasicClient::startCameraOps() {
2456    ATRACE_CALL();
2457
2458    int32_t res;
2459    // Notify app ops that the camera is not available
2460    mOpsCallback = new OpsCallback(this);
2461
2462    {
2463        ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
2464              __FUNCTION__, String8(mClientPackageName).string(), mClientUid);
2465    }
2466
2467    mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA,
2468            mClientPackageName, mOpsCallback);
2469    res = mAppOpsManager.startOp(AppOpsManager::OP_CAMERA,
2470            mClientUid, mClientPackageName);
2471
2472    if (res == AppOpsManager::MODE_ERRORED) {
2473        ALOGI("Camera %s: Access for \"%s\" has been revoked",
2474                mCameraIdStr.string(), String8(mClientPackageName).string());
2475        return PERMISSION_DENIED;
2476    }
2477
2478    if (res == AppOpsManager::MODE_IGNORED) {
2479        ALOGI("Camera %s: Access for \"%s\" has been restricted",
2480                mCameraIdStr.string(), String8(mClientPackageName).string());
2481        // Return the same error as for device policy manager rejection
2482        return -EACCES;
2483    }
2484
2485    mOpsActive = true;
2486
2487    // Transition device availability listeners from PRESENT -> NOT_AVAILABLE
2488    sCameraService->updateStatus(StatusInternal::NOT_AVAILABLE, mCameraIdStr);
2489
2490    // Transition device state to OPEN
2491    sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
2492            mCameraIdStr);
2493
2494    return OK;
2495}
2496
2497status_t CameraService::BasicClient::finishCameraOps() {
2498    ATRACE_CALL();
2499
2500    // Check if startCameraOps succeeded, and if so, finish the camera op
2501    if (mOpsActive) {
2502        // Notify app ops that the camera is available again
2503        mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid,
2504                mClientPackageName);
2505        mOpsActive = false;
2506
2507        std::initializer_list<StatusInternal> rejected = {StatusInternal::PRESENT,
2508                StatusInternal::ENUMERATING};
2509
2510        // Transition to PRESENT if the camera is not in either of the rejected states
2511        sCameraService->updateStatus(StatusInternal::PRESENT,
2512                mCameraIdStr, rejected);
2513
2514        // Transition device state to CLOSED
2515        sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED,
2516                mCameraIdStr);
2517    }
2518    // Always stop watching, even if no camera op is active
2519    if (mOpsCallback != NULL) {
2520        mAppOpsManager.stopWatchingMode(mOpsCallback);
2521    }
2522    mOpsCallback.clear();
2523
2524    return OK;
2525}
2526
2527void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) {
2528    ATRACE_CALL();
2529
2530    String8 name(packageName);
2531    String8 myName(mClientPackageName);
2532
2533    if (op != AppOpsManager::OP_CAMERA) {
2534        ALOGW("Unexpected app ops notification received: %d", op);
2535        return;
2536    }
2537
2538    int32_t res;
2539    res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA,
2540            mClientUid, mClientPackageName);
2541    ALOGV("checkOp returns: %d, %s ", res,
2542            res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" :
2543            res == AppOpsManager::MODE_IGNORED ? "IGNORED" :
2544            res == AppOpsManager::MODE_ERRORED ? "ERRORED" :
2545            "UNKNOWN");
2546
2547    if (res != AppOpsManager::MODE_ALLOWED) {
2548        ALOGI("Camera %s: Access for \"%s\" revoked", mCameraIdStr.string(),
2549                myName.string());
2550        // Reset the client PID to allow server-initiated disconnect,
2551        // and to prevent further calls by client.
2552        mClientPid = getCallingPid();
2553        CaptureResultExtras resultExtras; // a dummy result (invalid)
2554        notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE, resultExtras);
2555        disconnect();
2556    }
2557}
2558
2559// ----------------------------------------------------------------------------
2560
2561void CameraService::Client::notifyError(int32_t errorCode,
2562        const CaptureResultExtras& resultExtras) {
2563    (void) errorCode;
2564    (void) resultExtras;
2565    if (mRemoteCallback != NULL) {
2566        mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0);
2567    } else {
2568        ALOGE("mRemoteCallback is NULL!!");
2569    }
2570}
2571
2572// NOTE: function is idempotent
2573binder::Status CameraService::Client::disconnect() {
2574    ALOGV("Client::disconnect");
2575    return BasicClient::disconnect();
2576}
2577
2578bool CameraService::Client::canCastToApiClient(apiLevel level) const {
2579    return level == API_1;
2580}
2581
2582CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client):
2583        mClient(client) {
2584}
2585
2586void CameraService::Client::OpsCallback::opChanged(int32_t op,
2587        const String16& packageName) {
2588    sp<BasicClient> client = mClient.promote();
2589    if (client != NULL) {
2590        client->opChanged(op, packageName);
2591    }
2592}
2593
2594// ----------------------------------------------------------------------------
2595//                  CameraState
2596// ----------------------------------------------------------------------------
2597
2598CameraService::CameraState::CameraState(const String8& id, int cost,
2599        const std::set<String8>& conflicting) : mId(id),
2600        mStatus(StatusInternal::PRESENT), mCost(cost), mConflicting(conflicting) {}
2601
2602CameraService::CameraState::~CameraState() {}
2603
2604CameraService::StatusInternal CameraService::CameraState::getStatus() const {
2605    Mutex::Autolock lock(mStatusLock);
2606    return mStatus;
2607}
2608
2609CameraParameters CameraService::CameraState::getShimParams() const {
2610    return mShimParams;
2611}
2612
2613void CameraService::CameraState::setShimParams(const CameraParameters& params) {
2614    mShimParams = params;
2615}
2616
2617int CameraService::CameraState::getCost() const {
2618    return mCost;
2619}
2620
2621std::set<String8> CameraService::CameraState::getConflicting() const {
2622    return mConflicting;
2623}
2624
2625String8 CameraService::CameraState::getId() const {
2626    return mId;
2627}
2628
2629// ----------------------------------------------------------------------------
2630//                  ClientEventListener
2631// ----------------------------------------------------------------------------
2632
2633void CameraService::ClientEventListener::onClientAdded(
2634        const resource_policy::ClientDescriptor<String8,
2635        sp<CameraService::BasicClient>>& descriptor) {
2636    const auto& basicClient = descriptor.getValue();
2637    if (basicClient.get() != nullptr) {
2638        BatteryNotifier& notifier(BatteryNotifier::getInstance());
2639        notifier.noteStartCamera(descriptor.getKey(),
2640                static_cast<int>(basicClient->getClientUid()));
2641    }
2642}
2643
2644void CameraService::ClientEventListener::onClientRemoved(
2645        const resource_policy::ClientDescriptor<String8,
2646        sp<CameraService::BasicClient>>& descriptor) {
2647    const auto& basicClient = descriptor.getValue();
2648    if (basicClient.get() != nullptr) {
2649        BatteryNotifier& notifier(BatteryNotifier::getInstance());
2650        notifier.noteStopCamera(descriptor.getKey(),
2651                static_cast<int>(basicClient->getClientUid()));
2652    }
2653}
2654
2655
2656// ----------------------------------------------------------------------------
2657//                  CameraClientManager
2658// ----------------------------------------------------------------------------
2659
2660CameraService::CameraClientManager::CameraClientManager() {
2661    setListener(std::make_shared<ClientEventListener>());
2662}
2663
2664CameraService::CameraClientManager::~CameraClientManager() {}
2665
2666sp<CameraService::BasicClient> CameraService::CameraClientManager::getCameraClient(
2667        const String8& id) const {
2668    auto descriptor = get(id);
2669    if (descriptor == nullptr) {
2670        return sp<BasicClient>{nullptr};
2671    }
2672    return descriptor->getValue();
2673}
2674
2675String8 CameraService::CameraClientManager::toString() const {
2676    auto all = getAll();
2677    String8 ret("[");
2678    bool hasAny = false;
2679    for (auto& i : all) {
2680        hasAny = true;
2681        String8 key = i->getKey();
2682        int32_t cost = i->getCost();
2683        int32_t pid = i->getOwnerId();
2684        int32_t score = i->getPriority().getScore();
2685        int32_t state = i->getPriority().getState();
2686        auto conflicting = i->getConflicting();
2687        auto clientSp = i->getValue();
2688        String8 packageName;
2689        userid_t clientUserId = 0;
2690        if (clientSp.get() != nullptr) {
2691            packageName = String8{clientSp->getPackageName()};
2692            uid_t clientUid = clientSp->getClientUid();
2693            clientUserId = multiuser_get_user_id(clientUid);
2694        }
2695        ret.appendFormat("\n(Camera ID: %s, Cost: %" PRId32 ", PID: %" PRId32 ", Score: %"
2696                PRId32 ", State: %" PRId32, key.string(), cost, pid, score, state);
2697
2698        if (clientSp.get() != nullptr) {
2699            ret.appendFormat("User Id: %d, ", clientUserId);
2700        }
2701        if (packageName.size() != 0) {
2702            ret.appendFormat("Client Package Name: %s", packageName.string());
2703        }
2704
2705        ret.append(", Conflicting Client Devices: {");
2706        for (auto& j : conflicting) {
2707            ret.appendFormat("%s, ", j.string());
2708        }
2709        ret.append("})");
2710    }
2711    if (hasAny) ret.append("\n");
2712    ret.append("]\n");
2713    return ret;
2714}
2715
2716CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2717        const String8& key, const sp<BasicClient>& value, int32_t cost,
2718        const std::set<String8>& conflictingKeys, int32_t score, int32_t ownerId,
2719        int32_t state) {
2720
2721    return std::make_shared<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>(
2722            key, value, cost, conflictingKeys, score, ownerId, state);
2723}
2724
2725CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2726        const sp<BasicClient>& value, const CameraService::DescriptorPtr& partial) {
2727    return makeClientDescriptor(partial->getKey(), value, partial->getCost(),
2728            partial->getConflicting(), partial->getPriority().getScore(),
2729            partial->getOwnerId(), partial->getPriority().getState());
2730}
2731
2732// ----------------------------------------------------------------------------
2733
2734static const int kDumpLockRetries = 50;
2735static const int kDumpLockSleep = 60000;
2736
2737static bool tryLock(Mutex& mutex)
2738{
2739    bool locked = false;
2740    for (int i = 0; i < kDumpLockRetries; ++i) {
2741        if (mutex.tryLock() == NO_ERROR) {
2742            locked = true;
2743            break;
2744        }
2745        usleep(kDumpLockSleep);
2746    }
2747    return locked;
2748}
2749
2750status_t CameraService::dump(int fd, const Vector<String16>& args) {
2751    ATRACE_CALL();
2752
2753    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
2754        dprintf(fd, "Permission Denial: can't dump CameraService from pid=%d, uid=%d\n",
2755                getCallingPid(),
2756                getCallingUid());
2757        return NO_ERROR;
2758    }
2759    bool locked = tryLock(mServiceLock);
2760    // failed to lock - CameraService is probably deadlocked
2761    if (!locked) {
2762        dprintf(fd, "!! CameraService may be deadlocked !!\n");
2763    }
2764
2765    if (!mInitialized) {
2766        dprintf(fd, "!! No camera HAL available !!\n");
2767
2768        // Dump event log for error information
2769        dumpEventLog(fd);
2770
2771        if (locked) mServiceLock.unlock();
2772        return NO_ERROR;
2773    }
2774    dprintf(fd, "\n== Service global info: ==\n\n");
2775    dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);
2776    dprintf(fd, "Number of normal camera devices: %d\n", mNumberOfNormalCameras);
2777    String8 activeClientString = mActiveClientManager.toString();
2778    dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());
2779    dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());
2780
2781    dumpEventLog(fd);
2782
2783    bool stateLocked = tryLock(mCameraStatesLock);
2784    if (!stateLocked) {
2785        dprintf(fd, "CameraStates in use, may be deadlocked\n");
2786    }
2787
2788    for (auto& state : mCameraStates) {
2789        String8 cameraId = state.first;
2790
2791        dprintf(fd, "== Camera device %s dynamic info: ==\n", cameraId.string());
2792
2793        CameraParameters p = state.second->getShimParams();
2794        if (!p.isEmpty()) {
2795            dprintf(fd, "  Camera1 API shim is using parameters:\n        ");
2796            p.dump(fd, args);
2797        }
2798
2799        auto clientDescriptor = mActiveClientManager.get(cameraId);
2800        if (clientDescriptor != nullptr) {
2801            dprintf(fd, "  Device %s is open. Client instance dump:\n",
2802                    cameraId.string());
2803            dprintf(fd, "    Client priority score: %d state: %d\n",
2804                    clientDescriptor->getPriority().getScore(),
2805                    clientDescriptor->getPriority().getState());
2806            dprintf(fd, "    Client PID: %d\n", clientDescriptor->getOwnerId());
2807
2808            auto client = clientDescriptor->getValue();
2809            dprintf(fd, "    Client package: %s\n",
2810                    String8(client->getPackageName()).string());
2811
2812            client->dumpClient(fd, args);
2813        } else {
2814            dprintf(fd, "  Device %s is closed, no client instance\n",
2815                    cameraId.string());
2816        }
2817
2818        if (mModule != nullptr) {
2819            dprintf(fd, "== Camera HAL device %s static information: ==\n", cameraId.string());
2820
2821            camera_info info;
2822            status_t rc = mModule->getCameraInfo(cameraIdToInt(cameraId), &info);
2823            int deviceVersion = -1;
2824            if (rc != OK) {
2825                dprintf(fd, "  Error reading static information!\n");
2826            } else {
2827                dprintf(fd, "  Facing: %s\n",
2828                        info.facing == CAMERA_FACING_BACK ? "BACK" :
2829                        info.facing == CAMERA_FACING_FRONT ? "FRONT" : "EXTERNAL");
2830                dprintf(fd, "  Orientation: %d\n", info.orientation);
2831
2832                if (mModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_0) {
2833                    deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
2834                } else {
2835                    deviceVersion = info.device_version;
2836                }
2837            }
2838
2839            auto conflicting = state.second->getConflicting();
2840            dprintf(fd, "  Resource Cost: %d\n", state.second->getCost());
2841            dprintf(fd, "  Conflicting Devices:");
2842            for (auto& id : conflicting) {
2843                dprintf(fd, " %s", id.string());
2844            }
2845            if (conflicting.size() == 0) {
2846                dprintf(fd, " NONE");
2847            }
2848            dprintf(fd, "\n");
2849
2850            dprintf(fd, "  Device version: %#x\n", deviceVersion);
2851            if (deviceVersion >= CAMERA_DEVICE_API_VERSION_3_0) {
2852                dprintf(fd, "  Device static metadata:\n");
2853                dump_indented_camera_metadata(info.static_camera_characteristics,
2854                        fd, /*verbosity*/2, /*indentation*/4);
2855            }
2856        }
2857
2858    }
2859
2860    if (stateLocked) mCameraStatesLock.unlock();
2861
2862    if (locked) mServiceLock.unlock();
2863
2864    if (mModule == nullptr) {
2865        mCameraProviderManager->dump(fd, args);
2866    } else {
2867        dprintf(fd, "\n== Camera Module HAL static info: ==\n");
2868        dprintf(fd, "Camera module HAL API version: 0x%x\n", mModule->getHalApiVersion());
2869        dprintf(fd, "Camera module API version: 0x%x\n", mModule->getModuleApiVersion());
2870        dprintf(fd, "Camera module name: %s\n", mModule->getModuleName());
2871        dprintf(fd, "Camera module author: %s\n", mModule->getModuleAuthor());
2872    }
2873
2874    dprintf(fd, "\n== Vendor tags: ==\n\n");
2875
2876    sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
2877    if (desc == NULL) {
2878        sp<VendorTagDescriptorCache> cache =
2879                VendorTagDescriptorCache::getGlobalVendorTagCache();
2880        if (cache == NULL) {
2881            dprintf(fd, "No vendor tags.\n");
2882        } else {
2883            cache->dump(fd, /*verbosity*/2, /*indentation*/2);
2884        }
2885    } else {
2886        desc->dump(fd, /*verbosity*/2, /*indentation*/2);
2887    }
2888
2889    // Dump camera traces if there were any
2890    dprintf(fd, "\n");
2891    camera3::CameraTraces::dump(fd, args);
2892
2893    // Process dump arguments, if any
2894    int n = args.size();
2895    String16 verboseOption("-v");
2896    String16 unreachableOption("--unreachable");
2897    for (int i = 0; i < n; i++) {
2898        if (args[i] == verboseOption) {
2899            // change logging level
2900            if (i + 1 >= n) continue;
2901            String8 levelStr(args[i+1]);
2902            int level = atoi(levelStr.string());
2903            dprintf(fd, "\nSetting log level to %d.\n", level);
2904            setLogLevel(level);
2905        } else if (args[i] == unreachableOption) {
2906            // Dump memory analysis
2907            // TODO - should limit be an argument parameter?
2908            UnreachableMemoryInfo info;
2909            bool success = GetUnreachableMemory(info, /*limit*/ 10000);
2910            if (!success) {
2911                dprintf(fd, "\n== Unable to dump unreachable memory. "
2912                        "Try disabling SELinux enforcement. ==\n");
2913            } else {
2914                dprintf(fd, "\n== Dumping unreachable memory: ==\n");
2915                std::string s = info.ToString(/*log_contents*/ true);
2916                write(fd, s.c_str(), s.size());
2917            }
2918        }
2919    }
2920    return NO_ERROR;
2921}
2922
2923void CameraService::dumpEventLog(int fd) {
2924    dprintf(fd, "\n== Camera service events log (most recent at top): ==\n");
2925
2926    Mutex::Autolock l(mLogLock);
2927    for (const auto& msg : mEventLog) {
2928        dprintf(fd, "  %s\n", msg.string());
2929    }
2930
2931    if (mEventLog.size() == DEFAULT_EVENT_LOG_LENGTH) {
2932        dprintf(fd, "  ...\n");
2933    } else if (mEventLog.size() == 0) {
2934        dprintf(fd, "  [no events yet]\n");
2935    }
2936    dprintf(fd, "\n");
2937}
2938
2939void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) {
2940    Mutex::Autolock al(mTorchClientMapMutex);
2941    for (size_t i = 0; i < mTorchClientMap.size(); i++) {
2942        if (mTorchClientMap[i] == who) {
2943            // turn off the torch mode that was turned on by dead client
2944            String8 cameraId = mTorchClientMap.keyAt(i);
2945            status_t res = mFlashlight->setTorchMode(cameraId, false);
2946            if (res) {
2947                ALOGE("%s: torch client died but couldn't turn off torch: "
2948                    "%s (%d)", __FUNCTION__, strerror(-res), res);
2949                return;
2950            }
2951            mTorchClientMap.removeItemsAt(i);
2952            break;
2953        }
2954    }
2955}
2956
2957/*virtual*/void CameraService::binderDied(const wp<IBinder> &who) {
2958
2959    /**
2960      * While tempting to promote the wp<IBinder> into a sp, it's actually not supported by the
2961      * binder driver
2962      */
2963
2964    logClientDied(getCallingPid(), String8("Binder died unexpectedly"));
2965
2966    // check torch client
2967    handleTorchClientBinderDied(who);
2968
2969    // check camera device client
2970    if(!evictClientIdByRemote(who)) {
2971        ALOGV("%s: Java client's binder death already cleaned up (normal case)", __FUNCTION__);
2972        return;
2973    }
2974
2975    ALOGE("%s: Java client's binder died, removing it from the list of active clients",
2976            __FUNCTION__);
2977}
2978
2979void CameraService::updateStatus(StatusInternal status, const String8& cameraId) {
2980    updateStatus(status, cameraId, {});
2981}
2982
2983void CameraService::updateStatus(StatusInternal status, const String8& cameraId,
2984        std::initializer_list<StatusInternal> rejectSourceStates) {
2985    // Do not lock mServiceLock here or can get into a deadlock from
2986    // connect() -> disconnect -> updateStatus
2987
2988    auto state = getCameraState(cameraId);
2989
2990    if (state == nullptr) {
2991        ALOGW("%s: Could not update the status for %s, no such device exists", __FUNCTION__,
2992                cameraId.string());
2993        return;
2994    }
2995
2996    // Update the status for this camera state, then send the onStatusChangedCallbacks to each
2997    // of the listeners with both the mStatusStatus and mStatusListenerLock held
2998    state->updateStatus(status, cameraId, rejectSourceStates, [this]
2999            (const String8& cameraId, StatusInternal status) {
3000
3001            if (status != StatusInternal::ENUMERATING) {
3002                // Update torch status if it has a flash unit.
3003                Mutex::Autolock al(mTorchStatusMutex);
3004                TorchModeStatus torchStatus;
3005                if (getTorchStatusLocked(cameraId, &torchStatus) !=
3006                        NAME_NOT_FOUND) {
3007                    TorchModeStatus newTorchStatus =
3008                            status == StatusInternal::PRESENT ?
3009                            TorchModeStatus::AVAILABLE_OFF :
3010                            TorchModeStatus::NOT_AVAILABLE;
3011                    if (torchStatus != newTorchStatus) {
3012                        onTorchStatusChangedLocked(cameraId, newTorchStatus);
3013                    }
3014                }
3015            }
3016
3017            Mutex::Autolock lock(mStatusListenerLock);
3018
3019            for (auto& listener : mListenerList) {
3020                listener->onStatusChanged(mapToInterface(status), String16(cameraId));
3021            }
3022        });
3023}
3024
3025template<class Func>
3026void CameraService::CameraState::updateStatus(StatusInternal status,
3027        const String8& cameraId,
3028        std::initializer_list<StatusInternal> rejectSourceStates,
3029        Func onStatusUpdatedLocked) {
3030    Mutex::Autolock lock(mStatusLock);
3031    StatusInternal oldStatus = mStatus;
3032    mStatus = status;
3033
3034    if (oldStatus == status) {
3035        return;
3036    }
3037
3038    ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
3039            cameraId.string(), oldStatus, status);
3040
3041    if (oldStatus == StatusInternal::NOT_PRESENT &&
3042            (status != StatusInternal::PRESENT &&
3043             status != StatusInternal::ENUMERATING)) {
3044
3045        ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
3046                __FUNCTION__);
3047        mStatus = oldStatus;
3048        return;
3049    }
3050
3051    /**
3052     * Sometimes we want to conditionally do a transition.
3053     * For example if a client disconnects, we want to go to PRESENT
3054     * only if we weren't already in NOT_PRESENT or ENUMERATING.
3055     */
3056    for (auto& rejectStatus : rejectSourceStates) {
3057        if (oldStatus == rejectStatus) {
3058            ALOGV("%s: Rejecting status transition for Camera ID %s,  since the source "
3059                    "state was was in one of the bad states.", __FUNCTION__, cameraId.string());
3060            mStatus = oldStatus;
3061            return;
3062        }
3063    }
3064
3065    onStatusUpdatedLocked(cameraId, status);
3066}
3067
3068void CameraService::updateProxyDeviceState(ICameraServiceProxy::CameraState newState,
3069        const String8& cameraId) {
3070    sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
3071    if (proxyBinder == nullptr) return;
3072    String16 id(cameraId);
3073    proxyBinder->notifyCameraState(id, newState);
3074}
3075
3076status_t CameraService::getTorchStatusLocked(
3077        const String8& cameraId,
3078        TorchModeStatus *status) const {
3079    if (!status) {
3080        return BAD_VALUE;
3081    }
3082    ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3083    if (index == NAME_NOT_FOUND) {
3084        // invalid camera ID or the camera doesn't have a flash unit
3085        return NAME_NOT_FOUND;
3086    }
3087
3088    *status = mTorchStatusMap.valueAt(index);
3089    return OK;
3090}
3091
3092status_t CameraService::setTorchStatusLocked(const String8& cameraId,
3093        TorchModeStatus status) {
3094    ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3095    if (index == NAME_NOT_FOUND) {
3096        return BAD_VALUE;
3097    }
3098    mTorchStatusMap.editValueAt(index) = status;
3099
3100    return OK;
3101}
3102
3103}; // namespace android
3104