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