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