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