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