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