CameraService.cpp revision 2f140ed90057ca0df3f9da8318241ecfb6dda9eb 
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
654Status CameraService::getCameraVendorTagDescriptor(
655        /*out*/
656        hardware::camera2::params::VendorTagDescriptor* desc) {
657    ATRACE_CALL();
658    if (!mInitialized) {
659        ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
660        return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available");
661    }
662    sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor();
663    if (globalDescriptor != nullptr) {
664        *desc = *(globalDescriptor.get());
665    }
666    return Status::ok();
667}
668
669int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
670    ATRACE_CALL();
671
672    int deviceVersion = 0;
673
674    if (mModule != nullptr) {
675        int id = cameraIdToInt(cameraId);
676        if (id < 0) return -1;
677
678        struct camera_info info;
679        if (mModule->getCameraInfo(id, &info) != OK) {
680            return -1;
681        }
682
683        if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
684            deviceVersion = info.device_version;
685        } else {
686            deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
687        }
688
689        if (facing) {
690            *facing = info.facing;
691        }
692    } else {
693        status_t res;
694        hardware::hidl_version maxVersion{0,0};
695        res = mCameraProviderManager->getHighestSupportedVersion(String8::std_string(cameraId),
696                &maxVersion);
697        if (res != OK) return -1;
698        deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());
699
700        hardware::CameraInfo info;
701        if (facing) {
702            res = mCameraProviderManager->getCameraInfo(String8::std_string(cameraId), &info);
703            if (res != OK) return -1;
704            *facing = info.facing;
705        }
706    }
707    return deviceVersion;
708}
709
710Status CameraService::filterGetInfoErrorCode(status_t err) {
711    switch(err) {
712        case NO_ERROR:
713            return Status::ok();
714        case BAD_VALUE:
715            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
716                    "CameraId is not valid for HAL module");
717        case NO_INIT:
718            return STATUS_ERROR(ERROR_DISCONNECTED,
719                    "Camera device not available");
720        default:
721            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
722                    "Camera HAL encountered error %d: %s",
723                    err, strerror(-err));
724    }
725}
726
727bool CameraService::setUpVendorTags() {
728    ATRACE_CALL();
729    if (mModule == nullptr) return false;
730
731    vendor_tag_ops_t vOps = vendor_tag_ops_t();
732
733    // Check if vendor operations have been implemented
734    if (!mModule->isVendorTagDefined()) {
735        ALOGI("%s: No vendor tags defined for this device.", __FUNCTION__);
736        return false;
737    }
738
739    mModule->getVendorTagOps(&vOps);
740
741    // Ensure all vendor operations are present
742    if (vOps.get_tag_count == NULL || vOps.get_all_tags == NULL ||
743            vOps.get_section_name == NULL || vOps.get_tag_name == NULL ||
744            vOps.get_tag_type == NULL) {
745        ALOGE("%s: Vendor tag operations not fully defined. Ignoring definitions."
746               , __FUNCTION__);
747        return false;
748    }
749
750    // Read all vendor tag definitions into a descriptor
751    sp<VendorTagDescriptor> desc;
752    status_t res;
753    if ((res = VendorTagDescriptor::createDescriptorFromOps(&vOps, /*out*/desc))
754            != OK) {
755        ALOGE("%s: Could not generate descriptor from vendor tag operations,"
756              "received error %s (%d). Camera clients will not be able to use"
757              "vendor tags", __FUNCTION__, strerror(res), res);
758        return false;
759    }
760
761    // Set the global descriptor to use with camera metadata
762    VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
763    return true;
764}
765
766Status CameraService::makeClient(const sp<CameraService>& cameraService,
767        const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
768        int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
769        int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
770        /*out*/sp<BasicClient>* client) {
771
772    if (halVersion < 0 || halVersion == deviceVersion) {
773        // Default path: HAL version is unspecified by caller, create CameraClient
774        // based on device version reported by the HAL.
775        switch(deviceVersion) {
776          case CAMERA_DEVICE_API_VERSION_1_0:
777            if (effectiveApiLevel == API_1) {  // Camera1 API route
778                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
779                *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
780                        facing, clientPid, clientUid, getpid(), legacyMode);
781            } else { // Camera2 API route
782                ALOGW("Camera using old HAL version: %d", deviceVersion);
783                return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
784                        "Camera device \"%s\" HAL version %d does not support camera2 API",
785                        cameraId.string(), deviceVersion);
786            }
787            break;
788          case CAMERA_DEVICE_API_VERSION_3_0:
789          case CAMERA_DEVICE_API_VERSION_3_1:
790          case CAMERA_DEVICE_API_VERSION_3_2:
791          case CAMERA_DEVICE_API_VERSION_3_3:
792          case CAMERA_DEVICE_API_VERSION_3_4:
793            if (effectiveApiLevel == API_1) { // Camera1 API route
794                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
795                *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
796                        facing, clientPid, clientUid, servicePid, legacyMode);
797            } else { // Camera2 API route
798                sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
799                        static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
800                *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
801                        facing, clientPid, clientUid, servicePid);
802            }
803            break;
804          default:
805            // Should not be reachable
806            ALOGE("Unknown camera device HAL version: %d", deviceVersion);
807            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
808                    "Camera device \"%s\" has unknown HAL version %d",
809                    cameraId.string(), deviceVersion);
810        }
811    } else {
812        // A particular HAL version is requested by caller. Create CameraClient
813        // based on the requested HAL version.
814        if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
815            halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
816            // Only support higher HAL version device opened as HAL1.0 device.
817            sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
818            *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
819                    facing, clientPid, clientUid, servicePid, legacyMode);
820        } else {
821            // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
822            ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
823                    " opened as HAL %x device", halVersion, deviceVersion,
824                    CAMERA_DEVICE_API_VERSION_1_0);
825            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
826                    "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
827                    cameraId.string(), deviceVersion, halVersion);
828        }
829    }
830    return Status::ok();
831}
832
833String8 CameraService::toString(std::set<userid_t> intSet) {
834    String8 s("");
835    bool first = true;
836    for (userid_t i : intSet) {
837        if (first) {
838            s.appendFormat("%d", i);
839            first = false;
840        } else {
841            s.appendFormat(", %d", i);
842        }
843    }
844    return s;
845}
846
847int32_t CameraService::mapToInterface(TorchModeStatus status) {
848    int32_t serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
849    switch (status) {
850        case TorchModeStatus::NOT_AVAILABLE:
851            serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
852            break;
853        case TorchModeStatus::AVAILABLE_OFF:
854            serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF;
855            break;
856        case TorchModeStatus::AVAILABLE_ON:
857            serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON;
858            break;
859        default:
860            ALOGW("Unknown new flash status: %d", status);
861    }
862    return serviceStatus;
863}
864
865CameraService::StatusInternal CameraService::mapToInternal(CameraDeviceStatus status) {
866    StatusInternal serviceStatus = StatusInternal::NOT_PRESENT;
867    switch (status) {
868        case CameraDeviceStatus::NOT_PRESENT:
869            serviceStatus = StatusInternal::NOT_PRESENT;
870            break;
871        case CameraDeviceStatus::PRESENT:
872            serviceStatus = StatusInternal::PRESENT;
873            break;
874        case CameraDeviceStatus::ENUMERATING:
875            serviceStatus = StatusInternal::ENUMERATING;
876            break;
877        default:
878            ALOGW("Unknown new HAL device status: %d", status);
879    }
880    return serviceStatus;
881}
882
883int32_t CameraService::mapToInterface(StatusInternal status) {
884    int32_t serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
885    switch (status) {
886        case StatusInternal::NOT_PRESENT:
887            serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
888            break;
889        case StatusInternal::PRESENT:
890            serviceStatus = ICameraServiceListener::STATUS_PRESENT;
891            break;
892        case StatusInternal::ENUMERATING:
893            serviceStatus = ICameraServiceListener::STATUS_ENUMERATING;
894            break;
895        case StatusInternal::NOT_AVAILABLE:
896            serviceStatus = ICameraServiceListener::STATUS_NOT_AVAILABLE;
897            break;
898        case StatusInternal::UNKNOWN:
899            serviceStatus = ICameraServiceListener::STATUS_UNKNOWN;
900            break;
901        default:
902            ALOGW("Unknown new internal device status: %d", status);
903    }
904    return serviceStatus;
905}
906
907Status CameraService::initializeShimMetadata(int cameraId) {
908    int uid = getCallingUid();
909
910    String16 internalPackageName("cameraserver");
911    String8 id = String8::format("%d", cameraId);
912    Status ret = Status::ok();
913    sp<Client> tmp = nullptr;
914    if (!(ret = connectHelper<ICameraClient,Client>(
915            sp<ICameraClient>{nullptr}, id, static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
916            internalPackageName, uid, USE_CALLING_PID,
917            API_1, /*legacyMode*/ false, /*shimUpdateOnly*/ true,
918            /*out*/ tmp)
919            ).isOk()) {
920        ALOGE("%s: Error initializing shim metadata: %s", __FUNCTION__, ret.toString8().string());
921    }
922    return ret;
923}
924
925Status CameraService::getLegacyParametersLazy(int cameraId,
926        /*out*/
927        CameraParameters* parameters) {
928
929    ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId);
930
931    Status ret = Status::ok();
932
933    if (parameters == NULL) {
934        ALOGE("%s: parameters must not be null", __FUNCTION__);
935        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
936    }
937
938    String8 id = String8::format("%d", cameraId);
939
940    // Check if we already have parameters
941    {
942        // Scope for service lock
943        Mutex::Autolock lock(mServiceLock);
944        auto cameraState = getCameraState(id);
945        if (cameraState == nullptr) {
946            ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
947            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
948                    "Invalid camera ID: %s", id.string());
949        }
950        CameraParameters p = cameraState->getShimParams();
951        if (!p.isEmpty()) {
952            *parameters = p;
953            return ret;
954        }
955    }
956
957    int64_t token = IPCThreadState::self()->clearCallingIdentity();
958    ret = initializeShimMetadata(cameraId);
959    IPCThreadState::self()->restoreCallingIdentity(token);
960    if (!ret.isOk()) {
961        // Error already logged by callee
962        return ret;
963    }
964
965    // Check for parameters again
966    {
967        // Scope for service lock
968        Mutex::Autolock lock(mServiceLock);
969        auto cameraState = getCameraState(id);
970        if (cameraState == nullptr) {
971            ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
972            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
973                    "Invalid camera ID: %s", id.string());
974        }
975        CameraParameters p = cameraState->getShimParams();
976        if (!p.isEmpty()) {
977            *parameters = p;
978            return ret;
979        }
980    }
981
982    ALOGE("%s: Parameters were not initialized, or were empty.  Device may not be present.",
983            __FUNCTION__);
984    return STATUS_ERROR(ERROR_INVALID_OPERATION, "Unable to initialize legacy parameters");
985}
986
987// Can camera service trust the caller based on the calling UID?
988static bool isTrustedCallingUid(uid_t uid) {
989    switch (uid) {
990        case AID_MEDIA:        // mediaserver
991        case AID_CAMERASERVER: // cameraserver
992        case AID_RADIO:        // telephony
993            return true;
994        default:
995            return false;
996    }
997}
998
999Status CameraService::validateConnectLocked(const String8& cameraId,
1000        const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid,
1001        /*out*/int& originalClientPid) const {
1002
1003#ifdef __BRILLO__
1004    UNUSED(clientName8);
1005    UNUSED(clientUid);
1006    UNUSED(clientPid);
1007    UNUSED(originalClientPid);
1008#else
1009    Status allowed = validateClientPermissionsLocked(cameraId, clientName8, clientUid, clientPid,
1010            originalClientPid);
1011    if (!allowed.isOk()) {
1012        return allowed;
1013    }
1014#endif  // __BRILLO__
1015
1016    int callingPid = getCallingPid();
1017
1018    if (!mInitialized) {
1019        ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)",
1020                callingPid);
1021        return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1022                "No camera HAL module available to open camera device \"%s\"", cameraId.string());
1023    }
1024
1025    if (getCameraState(cameraId) == nullptr) {
1026        ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
1027                cameraId.string());
1028        return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1029                "No camera device with ID \"%s\" available", cameraId.string());
1030    }
1031
1032    status_t err = checkIfDeviceIsUsable(cameraId);
1033    if (err != NO_ERROR) {
1034        switch(err) {
1035            case -ENODEV:
1036            case -EBUSY:
1037                return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1038                        "No camera device with ID \"%s\" currently available", cameraId.string());
1039            default:
1040                return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1041                        "Unknown error connecting to ID \"%s\"", cameraId.string());
1042        }
1043    }
1044    return Status::ok();
1045}
1046
1047Status CameraService::validateClientPermissionsLocked(const String8& cameraId,
1048        const String8& clientName8, int& clientUid, int& clientPid,
1049        /*out*/int& originalClientPid) const {
1050    int callingPid = getCallingPid();
1051    int callingUid = getCallingUid();
1052
1053    // Check if we can trust clientUid
1054    if (clientUid == USE_CALLING_UID) {
1055        clientUid = callingUid;
1056    } else if (!isTrustedCallingUid(callingUid)) {
1057        ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
1058                "(don't trust clientUid %d)", callingPid, callingUid, clientUid);
1059        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1060                "Untrusted caller (calling PID %d, UID %d) trying to "
1061                "forward camera access to camera %s for client %s (PID %d, UID %d)",
1062                callingPid, callingUid, cameraId.string(),
1063                clientName8.string(), clientUid, clientPid);
1064    }
1065
1066    // Check if we can trust clientPid
1067    if (clientPid == USE_CALLING_PID) {
1068        clientPid = callingPid;
1069    } else if (!isTrustedCallingUid(callingUid)) {
1070        ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
1071                "(don't trust clientPid %d)", callingPid, callingUid, clientPid);
1072        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1073                "Untrusted caller (calling PID %d, UID %d) trying to "
1074                "forward camera access to camera %s for client %s (PID %d, UID %d)",
1075                callingPid, callingUid, cameraId.string(),
1076                clientName8.string(), clientUid, clientPid);
1077    }
1078
1079    // If it's not calling from cameraserver, check the permission.
1080    if (callingPid != getpid() &&
1081            !checkPermission(String16("android.permission.CAMERA"), clientPid, clientUid)) {
1082        ALOGE("Permission Denial: can't use the camera pid=%d, uid=%d", clientPid, clientUid);
1083        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1084                "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" without camera permission",
1085                clientName8.string(), clientUid, clientPid, cameraId.string());
1086    }
1087
1088    // Only use passed in clientPid to check permission. Use calling PID as the client PID that's
1089    // connected to camera service directly.
1090    originalClientPid = clientPid;
1091    clientPid = callingPid;
1092
1093    userid_t clientUserId = multiuser_get_user_id(clientUid);
1094
1095    // Only allow clients who are being used by the current foreground device user, unless calling
1096    // from our own process.
1097    if (callingPid != getpid() && (mAllowedUsers.find(clientUserId) == mAllowedUsers.end())) {
1098        ALOGE("CameraService::connect X (PID %d) rejected (cannot connect from "
1099                "device user %d, currently allowed device users: %s)", callingPid, clientUserId,
1100                toString(mAllowedUsers).string());
1101        return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1102                "Callers from device user %d are not currently allowed to connect to camera \"%s\"",
1103                clientUserId, cameraId.string());
1104    }
1105
1106    return Status::ok();
1107}
1108
1109status_t CameraService::checkIfDeviceIsUsable(const String8& cameraId) const {
1110    auto cameraState = getCameraState(cameraId);
1111    int callingPid = getCallingPid();
1112    if (cameraState == nullptr) {
1113        ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
1114                cameraId.string());
1115        return -ENODEV;
1116    }
1117
1118    StatusInternal currentStatus = cameraState->getStatus();
1119    if (currentStatus == StatusInternal::NOT_PRESENT) {
1120        ALOGE("CameraService::connect X (PID %d) rejected (camera %s is not connected)",
1121                callingPid, cameraId.string());
1122        return -ENODEV;
1123    } else if (currentStatus == StatusInternal::ENUMERATING) {
1124        ALOGE("CameraService::connect X (PID %d) rejected, (camera %s is initializing)",
1125                callingPid, cameraId.string());
1126        return -EBUSY;
1127    }
1128
1129    return NO_ERROR;
1130}
1131
1132void CameraService::finishConnectLocked(const sp<BasicClient>& client,
1133        const CameraService::DescriptorPtr& desc) {
1134
1135    // Make a descriptor for the incoming client
1136    auto clientDescriptor = CameraService::CameraClientManager::makeClientDescriptor(client, desc);
1137    auto evicted = mActiveClientManager.addAndEvict(clientDescriptor);
1138
1139    logConnected(desc->getKey(), static_cast<int>(desc->getOwnerId()),
1140            String8(client->getPackageName()));
1141
1142    if (evicted.size() > 0) {
1143        // This should never happen - clients should already have been removed in disconnect
1144        for (auto& i : evicted) {
1145            ALOGE("%s: Invalid state: Client for camera %s was not removed in disconnect",
1146                    __FUNCTION__, i->getKey().string());
1147        }
1148
1149        LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, clients not evicted properly",
1150                __FUNCTION__);
1151    }
1152
1153    // And register a death notification for the client callback. Do
1154    // this last to avoid Binder policy where a nested Binder
1155    // transaction might be pre-empted to service the client death
1156    // notification if the client process dies before linkToDeath is
1157    // invoked.
1158    sp<IBinder> remoteCallback = client->getRemote();
1159    if (remoteCallback != nullptr) {
1160        remoteCallback->linkToDeath(this);
1161    }
1162}
1163
1164status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clientPid,
1165        apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
1166        /*out*/
1167        sp<BasicClient>* client,
1168        std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial) {
1169    ATRACE_CALL();
1170    status_t ret = NO_ERROR;
1171    std::vector<DescriptorPtr> evictedClients;
1172    DescriptorPtr clientDescriptor;
1173    {
1174        if (effectiveApiLevel == API_1) {
1175            // If we are using API1, any existing client for this camera ID with the same remote
1176            // should be returned rather than evicted to allow MediaRecorder to work properly.
1177
1178            auto current = mActiveClientManager.get(cameraId);
1179            if (current != nullptr) {
1180                auto clientSp = current->getValue();
1181                if (clientSp.get() != nullptr) { // should never be needed
1182                    if (!clientSp->canCastToApiClient(effectiveApiLevel)) {
1183                        ALOGW("CameraService connect called from same client, but with a different"
1184                                " API level, evicting prior client...");
1185                    } else if (clientSp->getRemote() == remoteCallback) {
1186                        ALOGI("CameraService::connect X (PID %d) (second call from same"
1187                                " app binder, returning the same client)", clientPid);
1188                        *client = clientSp;
1189                        return NO_ERROR;
1190                    }
1191                }
1192            }
1193        }
1194
1195        // Get current active client PIDs
1196        std::vector<int> ownerPids(mActiveClientManager.getAllOwners());
1197        ownerPids.push_back(clientPid);
1198
1199        std::vector<int> priorityScores(ownerPids.size());
1200        std::vector<int> states(ownerPids.size());
1201
1202        // Get priority scores of all active PIDs
1203        status_t err = ProcessInfoService::getProcessStatesScoresFromPids(
1204                ownerPids.size(), &ownerPids[0], /*out*/&states[0],
1205                /*out*/&priorityScores[0]);
1206        if (err != OK) {
1207            ALOGE("%s: Priority score query failed: %d",
1208                  __FUNCTION__, err);
1209            return err;
1210        }
1211
1212        // Update all active clients' priorities
1213        std::map<int,resource_policy::ClientPriority> pidToPriorityMap;
1214        for (size_t i = 0; i < ownerPids.size() - 1; i++) {
1215            pidToPriorityMap.emplace(ownerPids[i],
1216                    resource_policy::ClientPriority(priorityScores[i], states[i]));
1217        }
1218        mActiveClientManager.updatePriorities(pidToPriorityMap);
1219
1220        // Get state for the given cameraId
1221        auto state = getCameraState(cameraId);
1222        if (state == nullptr) {
1223            ALOGE("CameraService::connect X (PID %d) rejected (no camera device with ID %s)",
1224                clientPid, cameraId.string());
1225            // Should never get here because validateConnectLocked should have errored out
1226            return BAD_VALUE;
1227        }
1228
1229        // Make descriptor for incoming client
1230        clientDescriptor = CameraClientManager::makeClientDescriptor(cameraId,
1231                sp<BasicClient>{nullptr}, static_cast<int32_t>(state->getCost()),
1232                state->getConflicting(),
1233                priorityScores[priorityScores.size() - 1],
1234                clientPid,
1235                states[states.size() - 1]);
1236
1237        // Find clients that would be evicted
1238        auto evicted = mActiveClientManager.wouldEvict(clientDescriptor);
1239
1240        // If the incoming client was 'evicted,' higher priority clients have the camera in the
1241        // background, so we cannot do evictions
1242        if (std::find(evicted.begin(), evicted.end(), clientDescriptor) != evicted.end()) {
1243            ALOGE("CameraService::connect X (PID %d) rejected (existing client(s) with higher"
1244                    " priority).", clientPid);
1245
1246            sp<BasicClient> clientSp = clientDescriptor->getValue();
1247            String8 curTime = getFormattedCurrentTime();
1248            auto incompatibleClients =
1249                    mActiveClientManager.getIncompatibleClients(clientDescriptor);
1250
1251            String8 msg = String8::format("%s : DENIED connect device %s client for package %s "
1252                    "(PID %d, score %d state %d) due to eviction policy", curTime.string(),
1253                    cameraId.string(), packageName.string(), clientPid,
1254                    priorityScores[priorityScores.size() - 1],
1255                    states[states.size() - 1]);
1256
1257            for (auto& i : incompatibleClients) {
1258                msg.appendFormat("\n   - Blocked by existing device %s client for package %s"
1259                        "(PID %" PRId32 ", score %" PRId32 ", state %" PRId32 ")",
1260                        i->getKey().string(),
1261                        String8{i->getValue()->getPackageName()}.string(),
1262                        i->getOwnerId(), i->getPriority().getScore(),
1263                        i->getPriority().getState());
1264                ALOGE("   Conflicts with: Device %s, client package %s (PID %"
1265                        PRId32 ", score %" PRId32 ", state %" PRId32 ")", i->getKey().string(),
1266                        String8{i->getValue()->getPackageName()}.string(), i->getOwnerId(),
1267                        i->getPriority().getScore(), i->getPriority().getState());
1268            }
1269
1270            // Log the client's attempt
1271            Mutex::Autolock l(mLogLock);
1272            mEventLog.add(msg);
1273
1274            return -EBUSY;
1275        }
1276
1277        for (auto& i : evicted) {
1278            sp<BasicClient> clientSp = i->getValue();
1279            if (clientSp.get() == nullptr) {
1280                ALOGE("%s: Invalid state: Null client in active client list.", __FUNCTION__);
1281
1282                // TODO: Remove this
1283                LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, null client in active list",
1284                        __FUNCTION__);
1285                mActiveClientManager.remove(i);
1286                continue;
1287            }
1288
1289            ALOGE("CameraService::connect evicting conflicting client for camera ID %s",
1290                    i->getKey().string());
1291            evictedClients.push_back(i);
1292
1293            // Log the clients evicted
1294            logEvent(String8::format("EVICT device %s client held by package %s (PID"
1295                    " %" PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted by device %s client for"
1296                    " package %s (PID %d, score %" PRId32 ", state %" PRId32 ")",
1297                    i->getKey().string(), String8{clientSp->getPackageName()}.string(),
1298                    i->getOwnerId(), i->getPriority().getScore(),
1299                    i->getPriority().getState(), cameraId.string(),
1300                    packageName.string(), clientPid,
1301                    priorityScores[priorityScores.size() - 1],
1302                    states[states.size() - 1]));
1303
1304            // Notify the client of disconnection
1305            clientSp->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
1306                    CaptureResultExtras());
1307        }
1308    }
1309
1310    // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1311    // other clients from connecting in mServiceLockWrapper if held
1312    mServiceLock.unlock();
1313
1314    // Clear caller identity temporarily so client disconnect PID checks work correctly
1315    int64_t token = IPCThreadState::self()->clearCallingIdentity();
1316
1317    // Destroy evicted clients
1318    for (auto& i : evictedClients) {
1319        // Disconnect is blocking, and should only have returned when HAL has cleaned up
1320        i->getValue()->disconnect(); // Clients will remove themselves from the active client list
1321    }
1322
1323    IPCThreadState::self()->restoreCallingIdentity(token);
1324
1325    for (const auto& i : evictedClients) {
1326        ALOGV("%s: Waiting for disconnect to complete for client for device %s (PID %" PRId32 ")",
1327                __FUNCTION__, i->getKey().string(), i->getOwnerId());
1328        ret = mActiveClientManager.waitUntilRemoved(i, DEFAULT_DISCONNECT_TIMEOUT_NS);
1329        if (ret == TIMED_OUT) {
1330            ALOGE("%s: Timed out waiting for client for device %s to disconnect, "
1331                    "current clients:\n%s", __FUNCTION__, i->getKey().string(),
1332                    mActiveClientManager.toString().string());
1333            return -EBUSY;
1334        }
1335        if (ret != NO_ERROR) {
1336            ALOGE("%s: Received error waiting for client for device %s to disconnect: %s (%d), "
1337                    "current clients:\n%s", __FUNCTION__, i->getKey().string(), strerror(-ret),
1338                    ret, mActiveClientManager.toString().string());
1339            return ret;
1340        }
1341    }
1342
1343    evictedClients.clear();
1344
1345    // Once clients have been disconnected, relock
1346    mServiceLock.lock();
1347
1348    // Check again if the device was unplugged or something while we weren't holding mServiceLock
1349    if ((ret = checkIfDeviceIsUsable(cameraId)) != NO_ERROR) {
1350        return ret;
1351    }
1352
1353    *partial = clientDescriptor;
1354    return NO_ERROR;
1355}
1356
1357Status CameraService::connect(
1358        const sp<ICameraClient>& cameraClient,
1359        int cameraId,
1360        const String16& clientPackageName,
1361        int clientUid,
1362        int clientPid,
1363        /*out*/
1364        sp<ICamera>* device) {
1365
1366    ATRACE_CALL();
1367    Status ret = Status::ok();
1368    String8 id = String8::format("%d", cameraId);
1369    sp<Client> client = nullptr;
1370    ret = connectHelper<ICameraClient,Client>(cameraClient, id,
1371            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
1372            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
1373            /*out*/client);
1374
1375    if(!ret.isOk()) {
1376        logRejected(id, getCallingPid(), String8(clientPackageName),
1377                ret.toString8());
1378        return ret;
1379    }
1380
1381    *device = client;
1382    return ret;
1383}
1384
1385Status CameraService::connectLegacy(
1386        const sp<ICameraClient>& cameraClient,
1387        int cameraId, int halVersion,
1388        const String16& clientPackageName,
1389        int clientUid,
1390        /*out*/
1391        sp<ICamera>* device) {
1392
1393    ATRACE_CALL();
1394    String8 id = String8::format("%d", cameraId);
1395    if (mModule != nullptr) {
1396        int apiVersion = mModule->getModuleApiVersion();
1397        if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED &&
1398                apiVersion < CAMERA_MODULE_API_VERSION_2_3) {
1399            /*
1400             * Either the HAL version is unspecified in which case this just creates
1401             * a camera client selected by the latest device version, or
1402             * it's a particular version in which case the HAL must supported
1403             * the open_legacy call
1404             */
1405            String8 msg = String8::format("Camera HAL module version %x too old for connectLegacy!",
1406                    apiVersion);
1407            ALOGE("%s: %s",
1408                    __FUNCTION__, msg.string());
1409            logRejected(id, getCallingPid(), String8(clientPackageName),
1410                    msg);
1411            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1412        }
1413    }
1414
1415    Status ret = Status::ok();
1416    sp<Client> client = nullptr;
1417    ret = connectHelper<ICameraClient,Client>(cameraClient, id, halVersion,
1418            clientPackageName, clientUid, USE_CALLING_PID, API_1,
1419            /*legacyMode*/ true, /*shimUpdateOnly*/ false,
1420            /*out*/client);
1421
1422    if(!ret.isOk()) {
1423        logRejected(id, getCallingPid(), String8(clientPackageName),
1424                ret.toString8());
1425        return ret;
1426    }
1427
1428    *device = client;
1429    return ret;
1430}
1431
1432Status CameraService::connectDevice(
1433        const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
1434        const String16& cameraId,
1435        const String16& clientPackageName,
1436        int clientUid,
1437        /*out*/
1438        sp<hardware::camera2::ICameraDeviceUser>* device) {
1439
1440    ATRACE_CALL();
1441    Status ret = Status::ok();
1442    String8 id = String8(cameraId);
1443    sp<CameraDeviceClient> client = nullptr;
1444    ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
1445            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
1446            clientUid, USE_CALLING_PID, API_2,
1447            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
1448            /*out*/client);
1449
1450    if(!ret.isOk()) {
1451        logRejected(id, getCallingPid(), String8(clientPackageName),
1452                ret.toString8());
1453        return ret;
1454    }
1455
1456    *device = client;
1457    return ret;
1458}
1459
1460template<class CALLBACK, class CLIENT>
1461Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
1462        int halVersion, const String16& clientPackageName, int clientUid, int clientPid,
1463        apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
1464        /*out*/sp<CLIENT>& device) {
1465    binder::Status ret = binder::Status::ok();
1466
1467    String8 clientName8(clientPackageName);
1468
1469    int originalClientPid = 0;
1470
1471    ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
1472            "Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
1473            (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
1474            static_cast<int>(effectiveApiLevel));
1475
1476    sp<CLIENT> client = nullptr;
1477    {
1478        // Acquire mServiceLock and prevent other clients from connecting
1479        std::unique_ptr<AutoConditionLock> lock =
1480                AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
1481
1482        if (lock == nullptr) {
1483            ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
1484                    , clientPid);
1485            return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1486                    "Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
1487                    cameraId.string(), clientName8.string(), clientPid);
1488        }
1489
1490        // Enforce client permissions and do basic sanity checks
1491        if(!(ret = validateConnectLocked(cameraId, clientName8,
1492                /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
1493            return ret;
1494        }
1495
1496        // Check the shim parameters after acquiring lock, if they have already been updated and
1497        // we were doing a shim update, return immediately
1498        if (shimUpdateOnly) {
1499            auto cameraState = getCameraState(cameraId);
1500            if (cameraState != nullptr) {
1501                if (!cameraState->getShimParams().isEmpty()) return ret;
1502            }
1503        }
1504
1505        status_t err;
1506
1507        sp<BasicClient> clientTmp = nullptr;
1508        std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
1509        if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
1510                IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
1511                /*out*/&partial)) != NO_ERROR) {
1512            switch (err) {
1513                case -ENODEV:
1514                    return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1515                            "No camera device with ID \"%s\" currently available",
1516                            cameraId.string());
1517                case -EBUSY:
1518                    return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1519                            "Higher-priority client using camera, ID \"%s\" currently unavailable",
1520                            cameraId.string());
1521                default:
1522                    return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1523                            "Unexpected error %s (%d) opening camera \"%s\"",
1524                            strerror(-err), err, cameraId.string());
1525            }
1526        }
1527
1528        if (clientTmp.get() != nullptr) {
1529            // Handle special case for API1 MediaRecorder where the existing client is returned
1530            device = static_cast<CLIENT*>(clientTmp.get());
1531            return ret;
1532        }
1533
1534        // give flashlight a chance to close devices if necessary.
1535        mFlashlight->prepareDeviceOpen(cameraId);
1536
1537        int facing = -1;
1538        int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
1539        if (facing == -1) {
1540            ALOGE("%s: Unable to get camera device \"%s\"  facing", __FUNCTION__, cameraId.string());
1541            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1542                    "Unable to get camera device \"%s\" facing", cameraId.string());
1543        }
1544
1545        sp<BasicClient> tmp = nullptr;
1546        if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
1547                clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
1548                /*out*/&tmp)).isOk()) {
1549            return ret;
1550        }
1551        client = static_cast<CLIENT*>(tmp.get());
1552
1553        LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
1554                __FUNCTION__);
1555
1556        if (mModule != nullptr) {
1557            err = client->initialize(mModule);
1558        } else {
1559            err = client->initialize(mCameraProviderManager);
1560        }
1561
1562        if (err != OK) {
1563            ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
1564            // Errors could be from the HAL module open call or from AppOpsManager
1565            switch(err) {
1566                case BAD_VALUE:
1567                    return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1568                            "Illegal argument to HAL module for camera \"%s\"", cameraId.string());
1569                case -EBUSY:
1570                    return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1571                            "Camera \"%s\" is already open", cameraId.string());
1572                case -EUSERS:
1573                    return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1574                            "Too many cameras already open, cannot open camera \"%s\"",
1575                            cameraId.string());
1576                case PERMISSION_DENIED:
1577                    return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1578                            "No permission to open camera \"%s\"", cameraId.string());
1579                case -EACCES:
1580                    return STATUS_ERROR_FMT(ERROR_DISABLED,
1581                            "Camera \"%s\" disabled by policy", cameraId.string());
1582                case -ENODEV:
1583                default:
1584                    return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1585                            "Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
1586                            strerror(-err), err);
1587            }
1588        }
1589
1590        // Update shim paremeters for legacy clients
1591        if (effectiveApiLevel == API_1) {
1592            // Assume we have always received a Client subclass for API1
1593            sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
1594            String8 rawParams = shimClient->getParameters();
1595            CameraParameters params(rawParams);
1596
1597            auto cameraState = getCameraState(cameraId);
1598            if (cameraState != nullptr) {
1599                cameraState->setShimParams(params);
1600            } else {
1601                ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
1602                        __FUNCTION__, cameraId.string());
1603            }
1604        }
1605
1606        if (shimUpdateOnly) {
1607            // If only updating legacy shim parameters, immediately disconnect client
1608            mServiceLock.unlock();
1609            client->disconnect();
1610            mServiceLock.lock();
1611        } else {
1612            // Otherwise, add client to active clients list
1613            finishConnectLocked(client, partial);
1614        }
1615    } // lock is destroyed, allow further connect calls
1616
1617    // Important: release the mutex here so the client can call back into the service from its
1618    // destructor (can be at the end of the call)
1619    device = client;
1620    return ret;
1621}
1622
1623Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
1624        const sp<IBinder>& clientBinder) {
1625    Mutex::Autolock lock(mServiceLock);
1626
1627    ATRACE_CALL();
1628    if (enabled && clientBinder == nullptr) {
1629        ALOGE("%s: torch client binder is NULL", __FUNCTION__);
1630        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
1631                "Torch client Binder is null");
1632    }
1633
1634    String8 id = String8(cameraId.string());
1635    int uid = getCallingUid();
1636
1637    // verify id is valid.
1638    auto state = getCameraState(id);
1639    if (state == nullptr) {
1640        ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string());
1641        return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1642                "Camera ID \"%s\" is a not valid camera ID", id.string());
1643    }
1644
1645    StatusInternal cameraStatus = state->getStatus();
1646    if (cameraStatus != StatusInternal::PRESENT &&
1647            cameraStatus != StatusInternal::NOT_AVAILABLE) {
1648        ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus);
1649        return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1650                "Camera ID \"%s\" is a not valid camera ID", id.string());
1651    }
1652
1653    {
1654        Mutex::Autolock al(mTorchStatusMutex);
1655        TorchModeStatus status;
1656        status_t err = getTorchStatusLocked(id, &status);
1657        if (err != OK) {
1658            if (err == NAME_NOT_FOUND) {
1659                return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1660                        "Camera \"%s\" does not have a flash unit", id.string());
1661            }
1662            ALOGE("%s: getting current torch status failed for camera %s",
1663                    __FUNCTION__, id.string());
1664            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1665                    "Error updating torch status for camera \"%s\": %s (%d)", id.string(),
1666                    strerror(-err), err);
1667        }
1668
1669        if (status == TorchModeStatus::NOT_AVAILABLE) {
1670            if (cameraStatus == StatusInternal::NOT_AVAILABLE) {
1671                ALOGE("%s: torch mode of camera %s is not available because "
1672                        "camera is in use", __FUNCTION__, id.string());
1673                return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1674                        "Torch for camera \"%s\" is not available due to an existing camera user",
1675                        id.string());
1676            } else {
1677                ALOGE("%s: torch mode of camera %s is not available due to "
1678                        "insufficient resources", __FUNCTION__, id.string());
1679                return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1680                        "Torch for camera \"%s\" is not available due to insufficient resources",
1681                        id.string());
1682            }
1683        }
1684    }
1685
1686    {
1687        // Update UID map - this is used in the torch status changed callbacks, so must be done
1688        // before setTorchMode
1689        Mutex::Autolock al(mTorchUidMapMutex);
1690        if (mTorchUidMap.find(id) == mTorchUidMap.end()) {
1691            mTorchUidMap[id].first = uid;
1692            mTorchUidMap[id].second = uid;
1693        } else {
1694            // Set the pending UID
1695            mTorchUidMap[id].first = uid;
1696        }
1697    }
1698
1699    status_t err = mFlashlight->setTorchMode(id, enabled);
1700
1701    if (err != OK) {
1702        int32_t errorCode;
1703        String8 msg;
1704        switch (err) {
1705            case -ENOSYS:
1706                msg = String8::format("Camera \"%s\" has no flashlight",
1707                    id.string());
1708                errorCode = ERROR_ILLEGAL_ARGUMENT;
1709                break;
1710            default:
1711                msg = String8::format(
1712                    "Setting torch mode of camera \"%s\" to %d failed: %s (%d)",
1713                    id.string(), enabled, strerror(-err), err);
1714                errorCode = ERROR_INVALID_OPERATION;
1715        }
1716        ALOGE("%s: %s", __FUNCTION__, msg.string());
1717        return STATUS_ERROR(errorCode, msg.string());
1718    }
1719
1720    {
1721        // update the link to client's death
1722        Mutex::Autolock al(mTorchClientMapMutex);
1723        ssize_t index = mTorchClientMap.indexOfKey(id);
1724        if (enabled) {
1725            if (index == NAME_NOT_FOUND) {
1726                mTorchClientMap.add(id, clientBinder);
1727            } else {
1728                mTorchClientMap.valueAt(index)->unlinkToDeath(this);
1729                mTorchClientMap.replaceValueAt(index, clientBinder);
1730            }
1731            clientBinder->linkToDeath(this);
1732        } else if (index != NAME_NOT_FOUND) {
1733            mTorchClientMap.valueAt(index)->unlinkToDeath(this);
1734        }
1735    }
1736
1737    return Status::ok();
1738}
1739
1740Status CameraService::notifySystemEvent(int32_t eventId,
1741        const std::vector<int32_t>& args) {
1742    ATRACE_CALL();
1743
1744    switch(eventId) {
1745        case ICameraService::EVENT_USER_SWITCHED: {
1746            doUserSwitch(/*newUserIds*/ args);
1747            break;
1748        }
1749        case ICameraService::EVENT_NONE:
1750        default: {
1751            ALOGW("%s: Received invalid system event from system_server: %d", __FUNCTION__,
1752                    eventId);
1753            break;
1754        }
1755    }
1756    return Status::ok();
1757}
1758
1759Status CameraService::addListener(const sp<ICameraServiceListener>& listener,
1760        /*out*/
1761        std::vector<hardware::CameraStatus> *cameraStatuses) {
1762    ATRACE_CALL();
1763
1764    ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
1765
1766    if (listener == nullptr) {
1767        ALOGE("%s: Listener must not be null", __FUNCTION__);
1768        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to addListener");
1769    }
1770
1771    Mutex::Autolock lock(mServiceLock);
1772
1773    {
1774        Mutex::Autolock lock(mStatusListenerLock);
1775        for (auto& it : mListenerList) {
1776            if (IInterface::asBinder(it) == IInterface::asBinder(listener)) {
1777                ALOGW("%s: Tried to add listener %p which was already subscribed",
1778                      __FUNCTION__, listener.get());
1779                return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
1780            }
1781        }
1782
1783        mListenerList.push_back(listener);
1784    }
1785
1786    /* Collect current devices and status */
1787    {
1788        Mutex::Autolock lock(mCameraStatesLock);
1789        for (auto& i : mCameraStates) {
1790            cameraStatuses->emplace_back(i.first, mapToInterface(i.second->getStatus()));
1791        }
1792    }
1793
1794    /*
1795     * Immediately signal current torch status to this listener only
1796     * This may be a subset of all the devices, so don't include it in the response directly
1797     */
1798    {
1799        Mutex::Autolock al(mTorchStatusMutex);
1800        for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) {
1801            String16 id = String16(mTorchStatusMap.keyAt(i).string());
1802            listener->onTorchStatusChanged(mapToInterface(mTorchStatusMap.valueAt(i)), id);
1803        }
1804    }
1805
1806    return Status::ok();
1807}
1808
1809Status CameraService::removeListener(const sp<ICameraServiceListener>& listener) {
1810    ATRACE_CALL();
1811
1812    ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
1813
1814    if (listener == 0) {
1815        ALOGE("%s: Listener must not be null", __FUNCTION__);
1816        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to removeListener");
1817    }
1818
1819    Mutex::Autolock lock(mServiceLock);
1820
1821    {
1822        Mutex::Autolock lock(mStatusListenerLock);
1823        for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) {
1824            if (IInterface::asBinder(*it) == IInterface::asBinder(listener)) {
1825                mListenerList.erase(it);
1826                return Status::ok();
1827            }
1828        }
1829    }
1830
1831    ALOGW("%s: Tried to remove a listener %p which was not subscribed",
1832          __FUNCTION__, listener.get());
1833
1834    return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Unregistered listener given to removeListener");
1835}
1836
1837Status CameraService::getLegacyParameters(int cameraId, /*out*/String16* parameters) {
1838
1839    ATRACE_CALL();
1840    ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1841
1842    if (parameters == NULL) {
1843        ALOGE("%s: parameters must not be null", __FUNCTION__);
1844        return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
1845    }
1846
1847    Status ret = Status::ok();
1848
1849    CameraParameters shimParams;
1850    if (!(ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)).isOk()) {
1851        // Error logged by caller
1852        return ret;
1853    }
1854
1855    String8 shimParamsString8 = shimParams.flatten();
1856    String16 shimParamsString16 = String16(shimParamsString8);
1857
1858    *parameters = shimParamsString16;
1859
1860    return ret;
1861}
1862
1863Status CameraService::supportsCameraApi(const String16& cameraId, int apiVersion,
1864        /*out*/ bool *isSupported) {
1865    ATRACE_CALL();
1866
1867    const String8 id = String8(cameraId);
1868
1869    ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
1870
1871    switch (apiVersion) {
1872        case API_VERSION_1:
1873        case API_VERSION_2:
1874            break;
1875        default:
1876            String8 msg = String8::format("Unknown API version %d", apiVersion);
1877            ALOGE("%s: %s", __FUNCTION__, msg.string());
1878            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1879    }
1880
1881    int facing = -1;
1882    int deviceVersion = getDeviceVersion(id, /*out*/ &facing);
1883    if (facing == -1) {
1884        String8 msg = String8::format("Unable to get facing for camera device %s",
1885                id.string());
1886        ALOGE("%s: %s", __FUNCTION__, msg.string());
1887        return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
1888    }
1889    switch(deviceVersion) {
1890        case CAMERA_DEVICE_API_VERSION_1_0:
1891        case CAMERA_DEVICE_API_VERSION_3_0:
1892        case CAMERA_DEVICE_API_VERSION_3_1:
1893            if (apiVersion == API_VERSION_2) {
1894                ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim",
1895                        __FUNCTION__, id.string(), deviceVersion);
1896                *isSupported = false;
1897            } else { // if (apiVersion == API_VERSION_1) {
1898                ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported",
1899                        __FUNCTION__, id.string());
1900                *isSupported = true;
1901            }
1902            break;
1903        case CAMERA_DEVICE_API_VERSION_3_2:
1904        case CAMERA_DEVICE_API_VERSION_3_3:
1905        case CAMERA_DEVICE_API_VERSION_3_4:
1906            ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
1907                    __FUNCTION__, id.string());
1908            *isSupported = true;
1909            break;
1910        case -1: {
1911            String8 msg = String8::format("Unknown camera ID %s", id.string());
1912            ALOGE("%s: %s", __FUNCTION__, msg.string());
1913            return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1914        }
1915        default: {
1916            String8 msg = String8::format("Unknown device version %x for device %s",
1917                    deviceVersion, id.string());
1918            ALOGE("%s: %s", __FUNCTION__, msg.string());
1919            return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
1920        }
1921    }
1922
1923    return Status::ok();
1924}
1925
1926void CameraService::removeByClient(const BasicClient* client) {
1927    Mutex::Autolock lock(mServiceLock);
1928    for (auto& i : mActiveClientManager.getAll()) {
1929        auto clientSp = i->getValue();
1930        if (clientSp.get() == client) {
1931            mActiveClientManager.remove(i);
1932        }
1933    }
1934}
1935
1936bool CameraService::evictClientIdByRemote(const wp<IBinder>& remote) {
1937    const int callingPid = getCallingPid();
1938    const int servicePid = getpid();
1939    bool ret = false;
1940    {
1941        // Acquire mServiceLock and prevent other clients from connecting
1942        std::unique_ptr<AutoConditionLock> lock =
1943                AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
1944
1945
1946        std::vector<sp<BasicClient>> evicted;
1947        for (auto& i : mActiveClientManager.getAll()) {
1948            auto clientSp = i->getValue();
1949            if (clientSp.get() == nullptr) {
1950                ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
1951                mActiveClientManager.remove(i);
1952                continue;
1953            }
1954            if (remote == clientSp->getRemote() && (callingPid == servicePid ||
1955                    callingPid == clientSp->getClientPid())) {
1956                mActiveClientManager.remove(i);
1957                evicted.push_back(clientSp);
1958
1959                // Notify the client of disconnection
1960                clientSp->notifyError(
1961                        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
1962                        CaptureResultExtras());
1963            }
1964        }
1965
1966        // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1967        // other clients from connecting in mServiceLockWrapper if held
1968        mServiceLock.unlock();
1969
1970        // Do not clear caller identity, remote caller should be client proccess
1971
1972        for (auto& i : evicted) {
1973            if (i.get() != nullptr) {
1974                i->disconnect();
1975                ret = true;
1976            }
1977        }
1978
1979        // Reacquire mServiceLock
1980        mServiceLock.lock();
1981
1982    } // lock is destroyed, allow further connect calls
1983
1984    return ret;
1985}
1986
1987
1988/**
1989 * Check camera capabilities, such as support for basic color operation
1990 * Also check that the device HAL version is still in support
1991 */
1992int CameraService::checkCameraCapabilities(int id, camera_info info, int *latestStrangeCameraId) {
1993    if (mModule == nullptr) return NO_INIT;
1994
1995    // device_version undefined in CAMERA_MODULE_API_VERSION_1_0,
1996    // All CAMERA_MODULE_API_VERSION_1_0 devices are backward-compatible
1997    if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
1998        // Verify the device version is in the supported range
1999        switch (info.device_version) {
2000            case CAMERA_DEVICE_API_VERSION_1_0:
2001            case CAMERA_DEVICE_API_VERSION_3_0:
2002            case CAMERA_DEVICE_API_VERSION_3_1:
2003            case CAMERA_DEVICE_API_VERSION_3_2:
2004            case CAMERA_DEVICE_API_VERSION_3_3:
2005            case CAMERA_DEVICE_API_VERSION_3_4:
2006                // in support
2007                break;
2008            case CAMERA_DEVICE_API_VERSION_2_0:
2009            case CAMERA_DEVICE_API_VERSION_2_1:
2010                // no longer supported
2011            default:
2012                ALOGE("%s: Device %d has HAL version %x, which is not supported",
2013                        __FUNCTION__, id, info.device_version);
2014                String8 msg = String8::format(
2015                        "Unsupported device HAL version %x for device %d",
2016                        info.device_version, id);
2017                logServiceError(msg.string(), NO_INIT);
2018                return NO_INIT;
2019        }
2020    }
2021
2022    // Assume all devices pre-v3.3 are backward-compatible
2023    bool isBackwardCompatible = true;
2024    if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0
2025            && info.device_version >= CAMERA_DEVICE_API_VERSION_3_3) {
2026        isBackwardCompatible = false;
2027        status_t res;
2028        camera_metadata_ro_entry_t caps;
2029        res = find_camera_metadata_ro_entry(
2030            info.static_camera_characteristics,
2031            ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
2032            &caps);
2033        if (res != 0) {
2034            ALOGW("%s: Unable to find camera capabilities for camera device %d",
2035                    __FUNCTION__, id);
2036            caps.count = 0;
2037        }
2038        for (size_t i = 0; i < caps.count; i++) {
2039            if (caps.data.u8[i] ==
2040                    ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE) {
2041                isBackwardCompatible = true;
2042                break;
2043            }
2044        }
2045    }
2046
2047    if (!isBackwardCompatible) {
2048        mNumberOfNormalCameras--;
2049        *latestStrangeCameraId = id;
2050    } else {
2051        if (id > *latestStrangeCameraId) {
2052            ALOGE("%s: Normal camera ID %d higher than strange camera ID %d. "
2053                    "This is not allowed due backward-compatibility requirements",
2054                    __FUNCTION__, id, *latestStrangeCameraId);
2055            logServiceError("Invalid order of camera devices", NO_INIT);
2056            mNumberOfCameras = 0;
2057            mNumberOfNormalCameras = 0;
2058            return NO_INIT;
2059        }
2060    }
2061    return OK;
2062}
2063
2064std::shared_ptr<CameraService::CameraState> CameraService::getCameraState(
2065        const String8& cameraId) const {
2066    std::shared_ptr<CameraState> state;
2067    {
2068        Mutex::Autolock lock(mCameraStatesLock);
2069        auto iter = mCameraStates.find(cameraId);
2070        if (iter != mCameraStates.end()) {
2071            state = iter->second;
2072        }
2073    }
2074    return state;
2075}
2076
2077sp<CameraService::BasicClient> CameraService::removeClientLocked(const String8& cameraId) {
2078    // Remove from active clients list
2079    auto clientDescriptorPtr = mActiveClientManager.remove(cameraId);
2080    if (clientDescriptorPtr == nullptr) {
2081        ALOGW("%s: Could not evict client, no client for camera ID %s", __FUNCTION__,
2082                cameraId.string());
2083        return sp<BasicClient>{nullptr};
2084    }
2085
2086    return clientDescriptorPtr->getValue();
2087}
2088
2089void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) {
2090    // Acquire mServiceLock and prevent other clients from connecting
2091    std::unique_ptr<AutoConditionLock> lock =
2092            AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
2093
2094    std::set<userid_t> newAllowedUsers;
2095    for (size_t i = 0; i < newUserIds.size(); i++) {
2096        if (newUserIds[i] < 0) {
2097            ALOGE("%s: Bad user ID %d given during user switch, ignoring.",
2098                    __FUNCTION__, newUserIds[i]);
2099            return;
2100        }
2101        newAllowedUsers.insert(static_cast<userid_t>(newUserIds[i]));
2102    }
2103
2104
2105    if (newAllowedUsers == mAllowedUsers) {
2106        ALOGW("%s: Received notification of user switch with no updated user IDs.", __FUNCTION__);
2107        return;
2108    }
2109
2110    logUserSwitch(mAllowedUsers, newAllowedUsers);
2111
2112    mAllowedUsers = std::move(newAllowedUsers);
2113
2114    // Current user has switched, evict all current clients.
2115    std::vector<sp<BasicClient>> evicted;
2116    for (auto& i : mActiveClientManager.getAll()) {
2117        auto clientSp = i->getValue();
2118
2119        if (clientSp.get() == nullptr) {
2120            ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
2121            continue;
2122        }
2123
2124        // Don't evict clients that are still allowed.
2125        uid_t clientUid = clientSp->getClientUid();
2126        userid_t clientUserId = multiuser_get_user_id(clientUid);
2127        if (mAllowedUsers.find(clientUserId) != mAllowedUsers.end()) {
2128            continue;
2129        }
2130
2131        evicted.push_back(clientSp);
2132
2133        String8 curTime = getFormattedCurrentTime();
2134
2135        ALOGE("Evicting conflicting client for camera ID %s due to user change",
2136                i->getKey().string());
2137
2138        // Log the clients evicted
2139        logEvent(String8::format("EVICT device %s client held by package %s (PID %"
2140                PRId32 ", score %" PRId32 ", state %" PRId32 ")\n   - Evicted due"
2141                " to user switch.", i->getKey().string(),
2142                String8{clientSp->getPackageName()}.string(),
2143                i->getOwnerId(), i->getPriority().getScore(),
2144                i->getPriority().getState()));
2145
2146    }
2147
2148    // Do not hold mServiceLock while disconnecting clients, but retain the condition
2149    // blocking other clients from connecting in mServiceLockWrapper if held.
2150    mServiceLock.unlock();
2151
2152    // Clear caller identity temporarily so client disconnect PID checks work correctly
2153    int64_t token = IPCThreadState::self()->clearCallingIdentity();
2154
2155    for (auto& i : evicted) {
2156        i->disconnect();
2157    }
2158
2159    IPCThreadState::self()->restoreCallingIdentity(token);
2160
2161    // Reacquire mServiceLock
2162    mServiceLock.lock();
2163}
2164
2165void CameraService::logEvent(const char* event) {
2166    String8 curTime = getFormattedCurrentTime();
2167    Mutex::Autolock l(mLogLock);
2168    mEventLog.add(String8::format("%s : %s", curTime.string(), event));
2169}
2170
2171void CameraService::logDisconnected(const char* cameraId, int clientPid,
2172        const char* clientPackage) {
2173    // Log the clients evicted
2174    logEvent(String8::format("DISCONNECT device %s client for package %s (PID %d)", cameraId,
2175            clientPackage, clientPid));
2176}
2177
2178void CameraService::logConnected(const char* cameraId, int clientPid,
2179        const char* clientPackage) {
2180    // Log the clients evicted
2181    logEvent(String8::format("CONNECT device %s client for package %s (PID %d)", cameraId,
2182            clientPackage, clientPid));
2183}
2184
2185void CameraService::logRejected(const char* cameraId, int clientPid,
2186        const char* clientPackage, const char* reason) {
2187    // Log the client rejected
2188    logEvent(String8::format("REJECT device %s client for package %s (PID %d), reason: (%s)",
2189            cameraId, clientPackage, clientPid, reason));
2190}
2191
2192void CameraService::logUserSwitch(const std::set<userid_t>& oldUserIds,
2193        const std::set<userid_t>& newUserIds) {
2194    String8 newUsers = toString(newUserIds);
2195    String8 oldUsers = toString(oldUserIds);
2196    if (oldUsers.size() == 0) {
2197        oldUsers = "<None>";
2198    }
2199    // Log the new and old users
2200    logEvent(String8::format("USER_SWITCH previous allowed user IDs: %s, current allowed user IDs: %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 score = i->getPriority().getScore();
2681        int32_t state = i->getPriority().getState();
2682        auto conflicting = i->getConflicting();
2683        auto clientSp = i->getValue();
2684        String8 packageName;
2685        userid_t clientUserId = 0;
2686        if (clientSp.get() != nullptr) {
2687            packageName = String8{clientSp->getPackageName()};
2688            uid_t clientUid = clientSp->getClientUid();
2689            clientUserId = multiuser_get_user_id(clientUid);
2690        }
2691        ret.appendFormat("\n(Camera ID: %s, Cost: %" PRId32 ", PID: %" PRId32 ", Score: %"
2692                PRId32 ", State: %" PRId32, key.string(), cost, pid, score, state);
2693
2694        if (clientSp.get() != nullptr) {
2695            ret.appendFormat("User Id: %d, ", clientUserId);
2696        }
2697        if (packageName.size() != 0) {
2698            ret.appendFormat("Client Package Name: %s", packageName.string());
2699        }
2700
2701        ret.append(", Conflicting Client Devices: {");
2702        for (auto& j : conflicting) {
2703            ret.appendFormat("%s, ", j.string());
2704        }
2705        ret.append("})");
2706    }
2707    if (hasAny) ret.append("\n");
2708    ret.append("]\n");
2709    return ret;
2710}
2711
2712CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2713        const String8& key, const sp<BasicClient>& value, int32_t cost,
2714        const std::set<String8>& conflictingKeys, int32_t score, int32_t ownerId,
2715        int32_t state) {
2716
2717    return std::make_shared<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>(
2718            key, value, cost, conflictingKeys, score, ownerId, state);
2719}
2720
2721CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2722        const sp<BasicClient>& value, const CameraService::DescriptorPtr& partial) {
2723    return makeClientDescriptor(partial->getKey(), value, partial->getCost(),
2724            partial->getConflicting(), partial->getPriority().getScore(),
2725            partial->getOwnerId(), partial->getPriority().getState());
2726}
2727
2728// ----------------------------------------------------------------------------
2729
2730static const int kDumpLockRetries = 50;
2731static const int kDumpLockSleep = 60000;
2732
2733static bool tryLock(Mutex& mutex)
2734{
2735    bool locked = false;
2736    for (int i = 0; i < kDumpLockRetries; ++i) {
2737        if (mutex.tryLock() == NO_ERROR) {
2738            locked = true;
2739            break;
2740        }
2741        usleep(kDumpLockSleep);
2742    }
2743    return locked;
2744}
2745
2746status_t CameraService::dump(int fd, const Vector<String16>& args) {
2747    ATRACE_CALL();
2748
2749    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
2750        dprintf(fd, "Permission Denial: can't dump CameraService from pid=%d, uid=%d\n",
2751                getCallingPid(),
2752                getCallingUid());
2753        return NO_ERROR;
2754    }
2755    bool locked = tryLock(mServiceLock);
2756    // failed to lock - CameraService is probably deadlocked
2757    if (!locked) {
2758        dprintf(fd, "!! CameraService may be deadlocked !!\n");
2759    }
2760
2761    if (!mInitialized) {
2762        dprintf(fd, "!! No camera HAL available !!\n");
2763
2764        // Dump event log for error information
2765        dumpEventLog(fd);
2766
2767        if (locked) mServiceLock.unlock();
2768        return NO_ERROR;
2769    }
2770    dprintf(fd, "\n== Service global info: ==\n\n");
2771    dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);
2772    dprintf(fd, "Number of normal camera devices: %d\n", mNumberOfNormalCameras);
2773    String8 activeClientString = mActiveClientManager.toString();
2774    dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());
2775    dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());
2776
2777    dumpEventLog(fd);
2778
2779    bool stateLocked = tryLock(mCameraStatesLock);
2780    if (!stateLocked) {
2781        dprintf(fd, "CameraStates in use, may be deadlocked\n");
2782    }
2783
2784    for (auto& state : mCameraStates) {
2785        String8 cameraId = state.first;
2786
2787        dprintf(fd, "== Camera device %s dynamic info: ==\n", cameraId.string());
2788
2789        CameraParameters p = state.second->getShimParams();
2790        if (!p.isEmpty()) {
2791            dprintf(fd, "  Camera1 API shim is using parameters:\n        ");
2792            p.dump(fd, args);
2793        }
2794
2795        auto clientDescriptor = mActiveClientManager.get(cameraId);
2796        if (clientDescriptor != nullptr) {
2797            dprintf(fd, "  Device %s is open. Client instance dump:\n",
2798                    cameraId.string());
2799            dprintf(fd, "    Client priority score: %d state: %d\n",
2800                    clientDescriptor->getPriority().getScore(),
2801                    clientDescriptor->getPriority().getState());
2802            dprintf(fd, "    Client PID: %d\n", clientDescriptor->getOwnerId());
2803
2804            auto client = clientDescriptor->getValue();
2805            dprintf(fd, "    Client package: %s\n",
2806                    String8(client->getPackageName()).string());
2807
2808            client->dumpClient(fd, args);
2809        } else {
2810            dprintf(fd, "  Device %s is closed, no client instance\n",
2811                    cameraId.string());
2812        }
2813
2814        if (mModule != nullptr) {
2815            dprintf(fd, "== Camera HAL device %s static information: ==\n", cameraId.string());
2816
2817            camera_info info;
2818            status_t rc = mModule->getCameraInfo(cameraIdToInt(cameraId), &info);
2819            int deviceVersion = -1;
2820            if (rc != OK) {
2821                dprintf(fd, "  Error reading static information!\n");
2822            } else {
2823                dprintf(fd, "  Facing: %s\n",
2824                        info.facing == CAMERA_FACING_BACK ? "BACK" :
2825                        info.facing == CAMERA_FACING_FRONT ? "FRONT" : "EXTERNAL");
2826                dprintf(fd, "  Orientation: %d\n", info.orientation);
2827
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
2835            auto conflicting = state.second->getConflicting();
2836            dprintf(fd, "  Resource Cost: %d\n", state.second->getCost());
2837            dprintf(fd, "  Conflicting Devices:");
2838            for (auto& id : conflicting) {
2839                dprintf(fd, " %s", id.string());
2840            }
2841            if (conflicting.size() == 0) {
2842                dprintf(fd, " NONE");
2843            }
2844            dprintf(fd, "\n");
2845
2846            dprintf(fd, "  Device version: %#x\n", deviceVersion);
2847            if (deviceVersion >= CAMERA_DEVICE_API_VERSION_3_0) {
2848                dprintf(fd, "  Device static metadata:\n");
2849                dump_indented_camera_metadata(info.static_camera_characteristics,
2850                        fd, /*verbosity*/2, /*indentation*/4);
2851            }
2852        }
2853
2854    }
2855
2856    if (stateLocked) mCameraStatesLock.unlock();
2857
2858    if (locked) mServiceLock.unlock();
2859
2860    if (mModule == nullptr) {
2861        mCameraProviderManager->dump(fd, args);
2862    } else {
2863        dprintf(fd, "\n== Camera Module HAL static info: ==\n");
2864        dprintf(fd, "Camera module HAL API version: 0x%x\n", mModule->getHalApiVersion());
2865        dprintf(fd, "Camera module API version: 0x%x\n", mModule->getModuleApiVersion());
2866        dprintf(fd, "Camera module name: %s\n", mModule->getModuleName());
2867        dprintf(fd, "Camera module author: %s\n", mModule->getModuleAuthor());
2868    }
2869
2870    dprintf(fd, "\n== Vendor tags: ==\n\n");
2871
2872    sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
2873    if (desc == NULL) {
2874        dprintf(fd, "No vendor tags.\n");
2875    } else {
2876        desc->dump(fd, /*verbosity*/2, /*indentation*/2);
2877    }
2878
2879    // Dump camera traces if there were any
2880    dprintf(fd, "\n");
2881    camera3::CameraTraces::dump(fd, args);
2882
2883    // Process dump arguments, if any
2884    int n = args.size();
2885    String16 verboseOption("-v");
2886    String16 unreachableOption("--unreachable");
2887    for (int i = 0; i < n; i++) {
2888        if (args[i] == verboseOption) {
2889            // change logging level
2890            if (i + 1 >= n) continue;
2891            String8 levelStr(args[i+1]);
2892            int level = atoi(levelStr.string());
2893            dprintf(fd, "\nSetting log level to %d.\n", level);
2894            setLogLevel(level);
2895        } else if (args[i] == unreachableOption) {
2896            // Dump memory analysis
2897            // TODO - should limit be an argument parameter?
2898            UnreachableMemoryInfo info;
2899            bool success = GetUnreachableMemory(info, /*limit*/ 10000);
2900            if (!success) {
2901                dprintf(fd, "\n== Unable to dump unreachable memory. "
2902                        "Try disabling SELinux enforcement. ==\n");
2903            } else {
2904                dprintf(fd, "\n== Dumping unreachable memory: ==\n");
2905                std::string s = info.ToString(/*log_contents*/ true);
2906                write(fd, s.c_str(), s.size());
2907            }
2908        }
2909    }
2910    return NO_ERROR;
2911}
2912
2913void CameraService::dumpEventLog(int fd) {
2914    dprintf(fd, "\n== Camera service events log (most recent at top): ==\n");
2915
2916    Mutex::Autolock l(mLogLock);
2917    for (const auto& msg : mEventLog) {
2918        dprintf(fd, "  %s\n", msg.string());
2919    }
2920
2921    if (mEventLog.size() == DEFAULT_EVENT_LOG_LENGTH) {
2922        dprintf(fd, "  ...\n");
2923    } else if (mEventLog.size() == 0) {
2924        dprintf(fd, "  [no events yet]\n");
2925    }
2926    dprintf(fd, "\n");
2927}
2928
2929void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) {
2930    Mutex::Autolock al(mTorchClientMapMutex);
2931    for (size_t i = 0; i < mTorchClientMap.size(); i++) {
2932        if (mTorchClientMap[i] == who) {
2933            // turn off the torch mode that was turned on by dead client
2934            String8 cameraId = mTorchClientMap.keyAt(i);
2935            status_t res = mFlashlight->setTorchMode(cameraId, false);
2936            if (res) {
2937                ALOGE("%s: torch client died but couldn't turn off torch: "
2938                    "%s (%d)", __FUNCTION__, strerror(-res), res);
2939                return;
2940            }
2941            mTorchClientMap.removeItemsAt(i);
2942            break;
2943        }
2944    }
2945}
2946
2947/*virtual*/void CameraService::binderDied(const wp<IBinder> &who) {
2948
2949    /**
2950      * While tempting to promote the wp<IBinder> into a sp, it's actually not supported by the
2951      * binder driver
2952      */
2953
2954    logClientDied(getCallingPid(), String8("Binder died unexpectedly"));
2955
2956    // check torch client
2957    handleTorchClientBinderDied(who);
2958
2959    // check camera device client
2960    if(!evictClientIdByRemote(who)) {
2961        ALOGV("%s: Java client's binder death already cleaned up (normal case)", __FUNCTION__);
2962        return;
2963    }
2964
2965    ALOGE("%s: Java client's binder died, removing it from the list of active clients",
2966            __FUNCTION__);
2967}
2968
2969void CameraService::updateStatus(StatusInternal status, const String8& cameraId) {
2970    updateStatus(status, cameraId, {});
2971}
2972
2973void CameraService::updateStatus(StatusInternal status, const String8& cameraId,
2974        std::initializer_list<StatusInternal> rejectSourceStates) {
2975    // Do not lock mServiceLock here or can get into a deadlock from
2976    // connect() -> disconnect -> updateStatus
2977
2978    auto state = getCameraState(cameraId);
2979
2980    if (state == nullptr) {
2981        ALOGW("%s: Could not update the status for %s, no such device exists", __FUNCTION__,
2982                cameraId.string());
2983        return;
2984    }
2985
2986    // Update the status for this camera state, then send the onStatusChangedCallbacks to each
2987    // of the listeners with both the mStatusStatus and mStatusListenerLock held
2988    state->updateStatus(status, cameraId, rejectSourceStates, [this]
2989            (const String8& cameraId, StatusInternal status) {
2990
2991            if (status != StatusInternal::ENUMERATING) {
2992                // Update torch status if it has a flash unit.
2993                Mutex::Autolock al(mTorchStatusMutex);
2994                TorchModeStatus torchStatus;
2995                if (getTorchStatusLocked(cameraId, &torchStatus) !=
2996                        NAME_NOT_FOUND) {
2997                    TorchModeStatus newTorchStatus =
2998                            status == StatusInternal::PRESENT ?
2999                            TorchModeStatus::AVAILABLE_OFF :
3000                            TorchModeStatus::NOT_AVAILABLE;
3001                    if (torchStatus != newTorchStatus) {
3002                        onTorchStatusChangedLocked(cameraId, newTorchStatus);
3003                    }
3004                }
3005            }
3006
3007            Mutex::Autolock lock(mStatusListenerLock);
3008
3009            for (auto& listener : mListenerList) {
3010                listener->onStatusChanged(mapToInterface(status), String16(cameraId));
3011            }
3012        });
3013}
3014
3015template<class Func>
3016void CameraService::CameraState::updateStatus(StatusInternal status,
3017        const String8& cameraId,
3018        std::initializer_list<StatusInternal> rejectSourceStates,
3019        Func onStatusUpdatedLocked) {
3020    Mutex::Autolock lock(mStatusLock);
3021    StatusInternal oldStatus = mStatus;
3022    mStatus = status;
3023
3024    if (oldStatus == status) {
3025        return;
3026    }
3027
3028    ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
3029            cameraId.string(), oldStatus, status);
3030
3031    if (oldStatus == StatusInternal::NOT_PRESENT &&
3032            (status != StatusInternal::PRESENT &&
3033             status != StatusInternal::ENUMERATING)) {
3034
3035        ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
3036                __FUNCTION__);
3037        mStatus = oldStatus;
3038        return;
3039    }
3040
3041    /**
3042     * Sometimes we want to conditionally do a transition.
3043     * For example if a client disconnects, we want to go to PRESENT
3044     * only if we weren't already in NOT_PRESENT or ENUMERATING.
3045     */
3046    for (auto& rejectStatus : rejectSourceStates) {
3047        if (oldStatus == rejectStatus) {
3048            ALOGV("%s: Rejecting status transition for Camera ID %s,  since the source "
3049                    "state was was in one of the bad states.", __FUNCTION__, cameraId.string());
3050            mStatus = oldStatus;
3051            return;
3052        }
3053    }
3054
3055    onStatusUpdatedLocked(cameraId, status);
3056}
3057
3058void CameraService::updateProxyDeviceState(ICameraServiceProxy::CameraState newState,
3059        const String8& cameraId) {
3060    sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
3061    if (proxyBinder == nullptr) return;
3062    String16 id(cameraId);
3063    proxyBinder->notifyCameraState(id, newState);
3064}
3065
3066status_t CameraService::getTorchStatusLocked(
3067        const String8& cameraId,
3068        TorchModeStatus *status) const {
3069    if (!status) {
3070        return BAD_VALUE;
3071    }
3072    ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3073    if (index == NAME_NOT_FOUND) {
3074        // invalid camera ID or the camera doesn't have a flash unit
3075        return NAME_NOT_FOUND;
3076    }
3077
3078    *status = mTorchStatusMap.valueAt(index);
3079    return OK;
3080}
3081
3082status_t CameraService::setTorchStatusLocked(const String8& cameraId,
3083        TorchModeStatus status) {
3084    ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3085    if (index == NAME_NOT_FOUND) {
3086        return BAD_VALUE;
3087    }
3088    mTorchStatusMap.editValueAt(index) = status;
3089
3090    return OK;
3091}
3092
3093}; // namespace android
3094