blob: a1cb8eea3a3f7d79c3f33111eb1111158708a0e2 [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
Ruben Brunkd1176ef2014-02-21 10:51:38 -08002 * 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 */
Mathias Agopian65ab4712010-07-14 17:59:35 -070016
17#define LOG_TAG "CameraService"
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -070018#define ATRACE_TAG ATRACE_TAG_CAMERA
Iliyan Malchev8951a972011-04-14 16:55:59 -070019//#define LOG_NDEBUG 0
Mathias Agopian65ab4712010-07-14 17:59:35 -070020
Ruben Brunkcc776712015-02-17 20:18:47 -080021#include <algorithm>
22#include <climits>
Mathias Agopian65ab4712010-07-14 17:59:35 -070023#include <stdio.h>
Ruben Brunkcc776712015-02-17 20:18:47 -080024#include <cstring>
25#include <ctime>
26#include <string>
Mathias Agopian65ab4712010-07-14 17:59:35 -070027#include <sys/types.h>
Ruben Brunkcc776712015-02-17 20:18:47 -080028#include <inttypes.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070029#include <pthread.h>
30
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080031#include <android/hardware/ICamera.h>
32#include <android/hardware/ICameraClient.h>
33
Alex Deymo9c2a2c22016-08-25 11:59:14 -070034#include <android-base/macros.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080035#include <android-base/parseint.h>
Svet Ganova453d0d2018-01-11 15:37:58 -080036#include <binder/ActivityManager.h>
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080037#include <binder/AppOpsManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070038#include <binder/IPCThreadState.h>
39#include <binder/IServiceManager.h>
40#include <binder/MemoryBase.h>
41#include <binder/MemoryHeapBase.h>
Svet Ganova453d0d2018-01-11 15:37:58 -080042#include <binder/PermissionController.h>
Ruben Brunkcc776712015-02-17 20:18:47 -080043#include <binder/ProcessInfoService.h>
Svet Ganova453d0d2018-01-11 15:37:58 -080044#include <binder/IResultReceiver.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070045#include <cutils/atomic.h>
Nipun Kwatrab5ca4612010-09-11 19:31:10 -070046#include <cutils/properties.h>
Svet Ganova453d0d2018-01-11 15:37:58 -080047#include <cutils/misc.h>
Mathias Agopiandf712ea2012-02-25 18:48:35 -080048#include <gui/Surface.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070049#include <hardware/hardware.h>
Jayant Chowdharybe543d42018-08-15 13:16:14 -070050#include "hidl/HidlCameraService.h"
51#include <hidl/HidlTransportSupport.h>
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -080052#include <hwbinder/IPCThreadState.h>
Eino-Ville Talvalad89821e2016-04-20 11:23:50 -070053#include <memunreachable/memunreachable.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070054#include <media/AudioSystem.h>
Andreas Huber1b86fe02014-01-29 11:13:26 -080055#include <media/IMediaHTTPService.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070056#include <media/mediaplayer.h>
Ruben Brunk99e69712015-05-26 17:25:07 -070057#include <mediautils/BatteryNotifier.h>
Michael Grooverd1d435a2018-12-18 17:39:42 -080058#include <sensorprivacy/SensorPrivacyManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070059#include <utils/Errors.h>
60#include <utils/Log.h>
61#include <utils/String16.h>
Svet Ganov94ec46f2018-06-08 15:03:46 -070062#include <utils/SystemClock.h>
Ruben Brunkd1176ef2014-02-21 10:51:38 -080063#include <utils/Trace.h>
Chien-Yu Chen98a668f2015-12-18 14:10:33 -080064#include <private/android_filesystem_config.h>
Ruben Brunkd1176ef2014-02-21 10:51:38 -080065#include <system/camera_vendor_tags.h>
Ruben Brunkb2119af2014-05-09 19:57:56 -070066#include <system/camera_metadata.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080067
Ruben Brunkb2119af2014-05-09 19:57:56 -070068#include <system/camera.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070069
70#include "CameraService.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070071#include "api1/CameraClient.h"
72#include "api1/Camera2Client.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070073#include "api2/CameraDeviceClient.h"
Igor Murashkinff3e31d2013-10-23 16:40:06 -070074#include "utils/CameraTraces.h"
Emilian Peevbd8c5032018-02-14 23:05:40 +000075#include "utils/TagMonitor.h"
Jayant Chowdhary12361932018-08-27 14:46:13 -070076#include "utils/CameraThreadState.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070077
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -080078namespace {
79 const char* kPermissionServiceName = "permission";
80}; // namespace anonymous
81
Mathias Agopian65ab4712010-07-14 17:59:35 -070082namespace android {
83
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080084using binder::Status;
Jayant Chowdharybe543d42018-08-15 13:16:14 -070085using frameworks::cameraservice::service::V2_0::implementation::HidlCameraService;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -080086using hardware::ICamera;
87using hardware::ICameraClient;
Eino-Ville Talvalae8c96c72017-06-27 12:24:07 -070088using hardware::ICameraServiceProxy;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -080089using hardware::ICameraServiceListener;
90using hardware::camera::common::V1_0::CameraDeviceStatus;
91using hardware::camera::common::V1_0::TorchModeStatus;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080092
Mathias Agopian65ab4712010-07-14 17:59:35 -070093// ----------------------------------------------------------------------------
94// Logging support -- this is for debugging only
95// Use "adb shell dumpsys media.camera -v 1" to change it.
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -070096volatile int32_t gLogLevel = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -070097
Steve Blockb8a80522011-12-20 16:23:08 +000098#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
99#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700100
101static void setLogLevel(int level) {
102 android_atomic_write(level, &gLogLevel);
103}
104
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800105// Convenience methods for constructing binder::Status objects for error returns
106
107#define STATUS_ERROR(errorCode, errorString) \
108 binder::Status::fromServiceSpecificError(errorCode, \
109 String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString))
110
111#define STATUS_ERROR_FMT(errorCode, errorString, ...) \
112 binder::Status::fromServiceSpecificError(errorCode, \
113 String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, \
114 __VA_ARGS__))
115
Mathias Agopian65ab4712010-07-14 17:59:35 -0700116// ----------------------------------------------------------------------------
117
Svet Ganova453d0d2018-01-11 15:37:58 -0800118static const String16 sManageCameraPermission("android.permission.MANAGE_CAMERA");
119
Eino-Ville Talvala7d5569f2019-04-08 13:57:54 -0700120Mutex CameraService::sProxyMutex;
121sp<hardware::ICameraServiceProxy> CameraService::sCameraServiceProxy;
122
Eino-Ville Talvala49c97052016-01-12 14:29:40 -0800123CameraService::CameraService() :
124 mEventLog(DEFAULT_EVENT_LOG_LENGTH),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800125 mNumberOfCameras(0),
Emilian Peevf53f66e2017-04-11 14:29:43 +0100126 mSoundRef(0), mInitialized(false) {
Steve Blockdf64d152012-01-04 20:05:49 +0000127 ALOGI("CameraService started (pid=%d)", getpid());
Ruben Brunkcc776712015-02-17 20:18:47 -0800128 mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700129}
130
Iliyan Malchev8951a972011-04-14 16:55:59 -0700131void CameraService::onFirstRef()
132{
Ruben Brunkcc776712015-02-17 20:18:47 -0800133 ALOGI("CameraService process starting");
Igor Murashkin634a5152013-02-20 17:15:11 -0800134
Iliyan Malchev8951a972011-04-14 16:55:59 -0700135 BnCameraService::onFirstRef();
136
Ruben Brunk99e69712015-05-26 17:25:07 -0700137 // Update battery life tracking if service is restarting
138 BatteryNotifier& notifier(BatteryNotifier::getInstance());
139 notifier.noteResetCamera();
140 notifier.noteResetFlashlight();
141
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800142 status_t res = INVALID_OPERATION;
Eino-Ville Talvala9cbbc832017-01-23 15:39:53 -0800143
Emilian Peevf53f66e2017-04-11 14:29:43 +0100144 res = enumerateProviders();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800145 if (res == OK) {
146 mInitialized = true;
147 }
148
149 CameraService::pingCameraServiceProxy();
Svet Ganova453d0d2018-01-11 15:37:58 -0800150
151 mUidPolicy = new UidPolicy(this);
152 mUidPolicy->registerSelf();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800153 mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
154 mSensorPrivacyPolicy->registerSelf();
Jayant Chowdharybe543d42018-08-15 13:16:14 -0700155 sp<HidlCameraService> hcs = HidlCameraService::getInstance(this);
156 if (hcs->registerAsService() != android::OK) {
157 ALOGE("%s: Failed to register default android.frameworks.cameraservice.service@1.0",
158 __FUNCTION__);
159 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800160}
161
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800162status_t CameraService::enumerateProviders() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800163 status_t res;
Emilian Peevaee727d2017-05-04 16:35:48 +0100164
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800165 std::vector<std::string> deviceIds;
166 {
167 Mutex::Autolock l(mServiceLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800168
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800169 if (nullptr == mCameraProviderManager.get()) {
170 mCameraProviderManager = new CameraProviderManager();
171 res = mCameraProviderManager->initialize(this);
172 if (res != OK) {
173 ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
174 __FUNCTION__, strerror(-res), res);
175 return res;
Emilian Peevaee727d2017-05-04 16:35:48 +0100176 }
177 }
178
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800179
180 // Setup vendor tags before we call get_camera_info the first time
181 // because HAL might need to setup static vendor keys in get_camera_info
182 // TODO: maybe put this into CameraProviderManager::initialize()?
183 mCameraProviderManager->setUpVendorTags();
184
185 if (nullptr == mFlashlight.get()) {
186 mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700187 }
188
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800189 res = mFlashlight->findFlashUnits();
190 if (res != OK) {
191 ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
192 }
193
194 deviceIds = mCameraProviderManager->getCameraDeviceIds();
195 }
196
197
198 for (auto& cameraId : deviceIds) {
199 String8 id8 = String8(cameraId.c_str());
Shuzhen Wang6ba3f5e2018-11-20 10:04:08 -0800200 if (getCameraState(id8) == nullptr) {
201 onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);
202 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800203 }
204
205 return OK;
206}
207
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700208sp<ICameraServiceProxy> CameraService::getCameraServiceProxy() {
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800209#ifndef __BRILLO__
Eino-Ville Talvala7d5569f2019-04-08 13:57:54 -0700210 Mutex::Autolock al(sProxyMutex);
211 if (sCameraServiceProxy == nullptr) {
212 sp<IServiceManager> sm = defaultServiceManager();
213 // Use checkService because cameraserver normally starts before the
214 // system server and the proxy service. So the long timeout that getService
215 // has before giving up is inappropriate.
216 sp<IBinder> binder = sm->checkService(String16("media.camera.proxy"));
217 if (binder != nullptr) {
218 sCameraServiceProxy = interface_cast<ICameraServiceProxy>(binder);
219 }
Ruben Brunk2823ce02015-05-19 17:25:13 -0700220 }
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800221#endif
Eino-Ville Talvala7d5569f2019-04-08 13:57:54 -0700222 return sCameraServiceProxy;
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700223}
224
225void CameraService::pingCameraServiceProxy() {
226 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
227 if (proxyBinder == nullptr) return;
Ruben Brunk2823ce02015-05-19 17:25:13 -0700228 proxyBinder->pingForUserUpdate();
Iliyan Malchev8951a972011-04-14 16:55:59 -0700229}
230
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800231void CameraService::broadcastTorchModeStatus(const String8& cameraId, TorchModeStatus status) {
232 Mutex::Autolock lock(mStatusListenerLock);
233
234 for (auto& i : mListenerList) {
Emilian Peev53722fa2019-02-22 17:47:20 -0800235 i.second->getListener()->onTorchStatusChanged(mapToInterface(status), String16{cameraId});
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800236 }
237}
238
Mathias Agopian65ab4712010-07-14 17:59:35 -0700239CameraService::~CameraService() {
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800240 VendorTagDescriptor::clearGlobalVendorTagDescriptor();
Svet Ganova453d0d2018-01-11 15:37:58 -0800241 mUidPolicy->unregisterSelf();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800242 mSensorPrivacyPolicy->unregisterSelf();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700243}
244
Emilian Peevaee727d2017-05-04 16:35:48 +0100245void CameraService::onNewProviderRegistered() {
246 enumerateProviders();
247}
248
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800249void CameraService::updateCameraNumAndIds() {
250 Mutex::Autolock l(mServiceLock);
251 mNumberOfCameras = mCameraProviderManager->getCameraCount();
252 mNormalDeviceIds =
253 mCameraProviderManager->getAPI1CompatibleCameraDeviceIds();
254}
255
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100256void CameraService::addStates(const String8 id) {
257 std::string cameraId(id.c_str());
258 hardware::camera::common::V1_0::CameraResourceCost cost;
259 status_t res = mCameraProviderManager->getResourceCost(cameraId, &cost);
260 if (res != OK) {
261 ALOGE("Failed to query device resource cost: %s (%d)", strerror(-res), res);
262 return;
263 }
264 std::set<String8> conflicting;
265 for (size_t i = 0; i < cost.conflictingDevices.size(); i++) {
266 conflicting.emplace(String8(cost.conflictingDevices[i].c_str()));
267 }
268
269 {
270 Mutex::Autolock lock(mCameraStatesLock);
271 mCameraStates.emplace(id, std::make_shared<CameraState>(id, cost.resourceCost,
272 conflicting));
273 }
274
275 if (mFlashlight->hasFlashUnit(id)) {
Emilian Peev7f25e5f2018-04-11 16:50:34 +0100276 Mutex::Autolock al(mTorchStatusMutex);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100277 mTorchStatusMap.add(id, TorchModeStatus::AVAILABLE_OFF);
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800278
279 broadcastTorchModeStatus(id, TorchModeStatus::AVAILABLE_OFF);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100280 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800281
282 updateCameraNumAndIds();
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100283 logDeviceAdded(id, "Device added");
284}
285
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100286void CameraService::removeStates(const String8 id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800287 updateCameraNumAndIds();
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100288 if (mFlashlight->hasFlashUnit(id)) {
Emilian Peev7f25e5f2018-04-11 16:50:34 +0100289 Mutex::Autolock al(mTorchStatusMutex);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100290 mTorchStatusMap.removeItem(id);
291 }
292
293 {
294 Mutex::Autolock lock(mCameraStatesLock);
295 mCameraStates.erase(id);
296 }
297}
298
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800299void CameraService::onDeviceStatusChanged(const String8& id,
300 CameraDeviceStatus newHalStatus) {
301 ALOGI("%s: Status changed for cameraId=%s, newStatus=%d", __FUNCTION__,
302 id.string(), newHalStatus);
Igor Murashkincba2c162013-03-20 15:56:31 -0700303
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800304 StatusInternal newStatus = mapToInternal(newHalStatus);
305
Ruben Brunkcc776712015-02-17 20:18:47 -0800306 std::shared_ptr<CameraState> state = getCameraState(id);
307
308 if (state == nullptr) {
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700309 if (newStatus == StatusInternal::PRESENT) {
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100310 ALOGI("%s: Unknown camera ID %s, a new camera is added",
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700311 __FUNCTION__, id.string());
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100312
313 // First add as absent to make sure clients are notified below
314 addStates(id);
315
316 updateStatus(newStatus, id);
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700317 } else {
318 ALOGE("%s: Bad camera ID %s", __FUNCTION__, id.string());
319 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700320 return;
321 }
322
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800323 StatusInternal oldStatus = state->getStatus();
Ruben Brunkcc776712015-02-17 20:18:47 -0800324
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800325 if (oldStatus == newStatus) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800326 ALOGE("%s: State transition to the same status %#x not allowed", __FUNCTION__, newStatus);
Igor Murashkincba2c162013-03-20 15:56:31 -0700327 return;
328 }
329
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800330 if (newStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunka8ca9152015-04-07 14:23:40 -0700331 logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus,
332 newStatus));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800333
334 // Set the device status to NOT_PRESENT, clients will no longer be able to connect
335 // to this device until the status changes
336 updateStatus(StatusInternal::NOT_PRESENT, id);
337
Ruben Brunkcc776712015-02-17 20:18:47 -0800338 sp<BasicClient> clientToDisconnect;
Igor Murashkincba2c162013-03-20 15:56:31 -0700339 {
Ruben Brunkcc776712015-02-17 20:18:47 -0800340 // Don't do this in updateStatus to avoid deadlock over mServiceLock
341 Mutex::Autolock lock(mServiceLock);
Igor Murashkincba2c162013-03-20 15:56:31 -0700342
Ruben Brunkcc776712015-02-17 20:18:47 -0800343 // Remove cached shim parameters
344 state->setShimParams(CameraParameters());
Igor Murashkincba2c162013-03-20 15:56:31 -0700345
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700346 // Remove the client from the list of active clients, if there is one
Ruben Brunkcc776712015-02-17 20:18:47 -0800347 clientToDisconnect = removeClientLocked(id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700348 }
Ruben Brunkcc776712015-02-17 20:18:47 -0800349
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700350 // Disconnect client
351 if (clientToDisconnect.get() != nullptr) {
352 ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL",
353 __FUNCTION__, id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -0800354 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800355 clientToDisconnect->notifyError(
356 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -0800357 CaptureResultExtras{});
Ruben Brunkcc776712015-02-17 20:18:47 -0800358 // Ensure not in binder RPC so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -0700359 LOG_ALWAYS_FATAL_IF(CameraThreadState::getCallingPid() != getpid(),
Ruben Brunkcc776712015-02-17 20:18:47 -0800360 "onDeviceStatusChanged must be called from the camera service process!");
361 clientToDisconnect->disconnect();
Igor Murashkincba2c162013-03-20 15:56:31 -0700362 }
363
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100364 removeStates(id);
Ruben Brunkcc776712015-02-17 20:18:47 -0800365 } else {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800366 if (oldStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunka8ca9152015-04-07 14:23:40 -0700367 logDeviceAdded(id, String8::format("Device status changed from %d to %d", oldStatus,
368 newStatus));
369 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800370 updateStatus(newStatus, id);
Igor Murashkincba2c162013-03-20 15:56:31 -0700371 }
372
Igor Murashkincba2c162013-03-20 15:56:31 -0700373}
374
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800375void CameraService::onTorchStatusChanged(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800376 TorchModeStatus newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800377 Mutex::Autolock al(mTorchStatusMutex);
378 onTorchStatusChangedLocked(cameraId, newStatus);
379}
380
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800381void CameraService::onTorchStatusChangedLocked(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800382 TorchModeStatus newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800383 ALOGI("%s: Torch status changed for cameraId=%s, newStatus=%d",
384 __FUNCTION__, cameraId.string(), newStatus);
385
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800386 TorchModeStatus status;
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800387 status_t res = getTorchStatusLocked(cameraId, &status);
388 if (res) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -0700389 ALOGE("%s: cannot get torch status of camera %s: %s (%d)",
390 __FUNCTION__, cameraId.string(), strerror(-res), res);
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800391 return;
392 }
393 if (status == newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800394 return;
395 }
396
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800397 res = setTorchStatusLocked(cameraId, newStatus);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800398 if (res) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800399 ALOGE("%s: Failed to set the torch status to %d: %s (%d)", __FUNCTION__,
400 (uint32_t)newStatus, strerror(-res), res);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800401 return;
402 }
403
Ruben Brunkcc776712015-02-17 20:18:47 -0800404 {
Ruben Brunk99e69712015-05-26 17:25:07 -0700405 // Update battery life logging for flashlight
Chien-Yu Chenfe751be2015-09-01 14:16:44 -0700406 Mutex::Autolock al(mTorchUidMapMutex);
Ruben Brunk99e69712015-05-26 17:25:07 -0700407 auto iter = mTorchUidMap.find(cameraId);
408 if (iter != mTorchUidMap.end()) {
409 int oldUid = iter->second.second;
410 int newUid = iter->second.first;
411 BatteryNotifier& notifier(BatteryNotifier::getInstance());
412 if (oldUid != newUid) {
413 // If the UID has changed, log the status and update current UID in mTorchUidMap
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800414 if (status == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700415 notifier.noteFlashlightOff(cameraId, oldUid);
416 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800417 if (newStatus == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700418 notifier.noteFlashlightOn(cameraId, newUid);
419 }
420 iter->second.second = newUid;
421 } else {
422 // If the UID has not changed, log the status
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800423 if (newStatus == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700424 notifier.noteFlashlightOn(cameraId, oldUid);
425 } else {
426 notifier.noteFlashlightOff(cameraId, oldUid);
427 }
428 }
429 }
430 }
431
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800432 broadcastTorchModeStatus(cameraId, newStatus);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800433}
434
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800435Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700436 ATRACE_CALL();
Emilian Peevaee727d2017-05-04 16:35:48 +0100437 Mutex::Autolock l(mServiceLock);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700438 switch (type) {
439 case CAMERA_TYPE_BACKWARD_COMPATIBLE:
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800440 *numCameras = static_cast<int>(mNormalDeviceIds.size());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800441 break;
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700442 case CAMERA_TYPE_ALL:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800443 *numCameras = mNumberOfCameras;
444 break;
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700445 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800446 ALOGW("%s: Unknown camera type %d",
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700447 __FUNCTION__, type);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800448 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
449 "Unknown camera type %d", type);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700450 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800451 return Status::ok();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700452}
453
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800454Status CameraService::getCameraInfo(int cameraId,
455 CameraInfo* cameraInfo) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700456 ATRACE_CALL();
Emilian Peevaee727d2017-05-04 16:35:48 +0100457 Mutex::Autolock l(mServiceLock);
458
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800459 if (!mInitialized) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800460 return STATUS_ERROR(ERROR_DISCONNECTED,
461 "Camera subsystem is not available");
Iliyan Malchev8951a972011-04-14 16:55:59 -0700462 }
463
Mathias Agopian65ab4712010-07-14 17:59:35 -0700464 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800465 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
466 "CameraId is not valid");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700467 }
468
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800469 Status ret = Status::ok();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800470 status_t err = mCameraProviderManager->getCameraInfo(
471 cameraIdIntToStrLocked(cameraId), cameraInfo);
Emilian Peevf53f66e2017-04-11 14:29:43 +0100472 if (err != OK) {
473 ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
474 "Error retrieving camera info from device %d: %s (%d)", cameraId,
475 strerror(-err), err);
Ruben Brunkcc776712015-02-17 20:18:47 -0800476 }
Emilian Peevf53f66e2017-04-11 14:29:43 +0100477
Ruben Brunkcc776712015-02-17 20:18:47 -0800478 return ret;
479}
Ruben Brunkb2119af2014-05-09 19:57:56 -0700480
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800481std::string CameraService::cameraIdIntToStrLocked(int cameraIdInt) {
482 if (cameraIdInt < 0 || cameraIdInt >= static_cast<int>(mNormalDeviceIds.size())) {
483 ALOGE("%s: input id %d invalid: valid range (0, %zu)",
484 __FUNCTION__, cameraIdInt, mNormalDeviceIds.size());
485 return std::string{};
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800486 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800487
488 return mNormalDeviceIds[cameraIdInt];
489}
490
491String8 CameraService::cameraIdIntToStr(int cameraIdInt) {
492 Mutex::Autolock lock(mServiceLock);
493 return String8(cameraIdIntToStrLocked(cameraIdInt).c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800494}
495
496Status CameraService::getCameraCharacteristics(const String16& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800497 CameraMetadata* cameraInfo) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700498 ATRACE_CALL();
Zhijun He2b59be82013-09-25 10:14:30 -0700499 if (!cameraInfo) {
500 ALOGE("%s: cameraInfo is NULL", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800501 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "cameraInfo is NULL");
Zhijun He2b59be82013-09-25 10:14:30 -0700502 }
503
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800504 if (!mInitialized) {
505 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800506 return STATUS_ERROR(ERROR_DISCONNECTED,
507 "Camera subsystem is not available");;
Zhijun He2b59be82013-09-25 10:14:30 -0700508 }
509
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800510 Status ret{};
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800511
Emilian Peevf53f66e2017-04-11 14:29:43 +0100512 status_t res = mCameraProviderManager->getCameraCharacteristics(
513 String8(cameraId).string(), cameraInfo);
514 if (res != OK) {
515 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Unable to retrieve camera "
516 "characteristics for device %s: %s (%d)", String8(cameraId).string(),
517 strerror(-res), res);
Ruben Brunkb2119af2014-05-09 19:57:56 -0700518 }
Zhijun He2b59be82013-09-25 10:14:30 -0700519
Jayant Chowdhary12361932018-08-27 14:46:13 -0700520 int callingPid = CameraThreadState::getCallingPid();
521 int callingUid = CameraThreadState::getCallingUid();
Emilian Peeve20c6372018-08-14 18:45:53 +0100522 std::vector<int32_t> tagsRemoved;
523 // If it's not calling from cameraserver, check the permission.
524 if ((callingPid != getpid()) &&
525 !checkPermission(String16("android.permission.CAMERA"), callingPid, callingUid)) {
526 res = cameraInfo->removePermissionEntries(
527 mCameraProviderManager->getProviderTagIdLocked(String8(cameraId).string()),
528 &tagsRemoved);
529 if (res != OK) {
530 cameraInfo->clear();
531 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to remove camera"
532 " characteristics needing camera permission for device %s: %s (%d)",
533 String8(cameraId).string(), strerror(-res), res);
534 }
535 }
536
537 if (!tagsRemoved.empty()) {
538 res = cameraInfo->update(ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION,
539 tagsRemoved.data(), tagsRemoved.size());
540 if (res != OK) {
541 cameraInfo->clear();
542 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to insert camera "
543 "keys needing permission for device %s: %s (%d)", String8(cameraId).string(),
544 strerror(-res), res);
545 }
546 }
547
Zhijun He2b59be82013-09-25 10:14:30 -0700548 return ret;
549}
550
Ruben Brunkcc776712015-02-17 20:18:47 -0800551String8 CameraService::getFormattedCurrentTime() {
552 time_t now = time(nullptr);
553 char formattedTime[64];
554 strftime(formattedTime, sizeof(formattedTime), "%m-%d %H:%M:%S", localtime(&now));
555 return String8(formattedTime);
556}
557
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800558Status CameraService::getCameraVendorTagDescriptor(
559 /*out*/
560 hardware::camera2::params::VendorTagDescriptor* desc) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700561 ATRACE_CALL();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800562 if (!mInitialized) {
563 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800564 return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available");
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800565 }
Eino-Ville Talvala1e74e242016-03-03 11:24:28 -0800566 sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor();
567 if (globalDescriptor != nullptr) {
568 *desc = *(globalDescriptor.get());
569 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800570 return Status::ok();
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800571}
572
Emilian Peev71c73a22017-03-21 16:35:51 +0000573Status CameraService::getCameraVendorTagCache(
574 /*out*/ hardware::camera2::params::VendorTagDescriptorCache* cache) {
575 ATRACE_CALL();
576 if (!mInitialized) {
577 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
578 return STATUS_ERROR(ERROR_DISCONNECTED,
579 "Camera subsystem not available");
580 }
581 sp<VendorTagDescriptorCache> globalCache =
582 VendorTagDescriptorCache::getGlobalVendorTagCache();
583 if (globalCache != nullptr) {
584 *cache = *(globalCache.get());
585 }
586 return Status::ok();
587}
588
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800589int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700590 ATRACE_CALL();
Igor Murashkin634a5152013-02-20 17:15:11 -0800591
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800592 int deviceVersion = 0;
593
Emilian Peevf53f66e2017-04-11 14:29:43 +0100594 status_t res;
595 hardware::hidl_version maxVersion{0,0};
596 res = mCameraProviderManager->getHighestSupportedVersion(cameraId.string(),
597 &maxVersion);
598 if (res != OK) return -1;
599 deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800600
Emilian Peevf53f66e2017-04-11 14:29:43 +0100601 hardware::CameraInfo info;
602 if (facing) {
603 res = mCameraProviderManager->getCameraInfo(cameraId.string(), &info);
Eino-Ville Talvala6963d0a2017-01-31 13:00:34 -0800604 if (res != OK) return -1;
Emilian Peevf53f66e2017-04-11 14:29:43 +0100605 *facing = info.facing;
Igor Murashkin634a5152013-02-20 17:15:11 -0800606 }
Emilian Peevf53f66e2017-04-11 14:29:43 +0100607
Igor Murashkin634a5152013-02-20 17:15:11 -0800608 return deviceVersion;
609}
610
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800611Status CameraService::filterGetInfoErrorCode(status_t err) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700612 switch(err) {
613 case NO_ERROR:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800614 return Status::ok();
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800615 case BAD_VALUE:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800616 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
617 "CameraId is not valid for HAL module");
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800618 case NO_INIT:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800619 return STATUS_ERROR(ERROR_DISCONNECTED,
620 "Camera device not available");
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700621 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800622 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
623 "Camera HAL encountered error %d: %s",
624 err, strerror(-err));
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700625 }
Igor Murashkinbfc99152013-02-27 12:55:20 -0800626}
627
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800628Status CameraService::makeClient(const sp<CameraService>& cameraService,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800629 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800630 int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700631 int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
Ruben Brunkcc776712015-02-17 20:18:47 -0800632 /*out*/sp<BasicClient>* client) {
633
Ruben Brunkcc776712015-02-17 20:18:47 -0800634 if (halVersion < 0 || halVersion == deviceVersion) {
635 // Default path: HAL version is unspecified by caller, create CameraClient
636 // based on device version reported by the HAL.
637 switch(deviceVersion) {
638 case CAMERA_DEVICE_API_VERSION_1_0:
639 if (effectiveApiLevel == API_1) { // Camera1 API route
640 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800641 *client = new CameraClient(cameraService, tmp, packageName,
642 api1CameraId, facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700643 getpid());
Ruben Brunkcc776712015-02-17 20:18:47 -0800644 } else { // Camera2 API route
645 ALOGW("Camera using old HAL version: %d", deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800646 return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800647 "Camera device \"%s\" HAL version %d does not support camera2 API",
648 cameraId.string(), deviceVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800649 }
650 break;
Ruben Brunkcc776712015-02-17 20:18:47 -0800651 case CAMERA_DEVICE_API_VERSION_3_0:
652 case CAMERA_DEVICE_API_VERSION_3_1:
653 case CAMERA_DEVICE_API_VERSION_3_2:
654 case CAMERA_DEVICE_API_VERSION_3_3:
Zhijun He4afbdec2016-05-04 15:42:51 -0700655 case CAMERA_DEVICE_API_VERSION_3_4:
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700656 case CAMERA_DEVICE_API_VERSION_3_5:
Ruben Brunkcc776712015-02-17 20:18:47 -0800657 if (effectiveApiLevel == API_1) { // Camera1 API route
658 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800659 *client = new Camera2Client(cameraService, tmp, packageName,
660 cameraId, api1CameraId,
661 facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700662 servicePid);
Ruben Brunkcc776712015-02-17 20:18:47 -0800663 } else { // Camera2 API route
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800664 sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
665 static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
666 *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
Ruben Brunkcc776712015-02-17 20:18:47 -0800667 facing, clientPid, clientUid, servicePid);
668 }
669 break;
670 default:
671 // Should not be reachable
672 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800673 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800674 "Camera device \"%s\" has unknown HAL version %d",
675 cameraId.string(), deviceVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800676 }
677 } else {
678 // A particular HAL version is requested by caller. Create CameraClient
679 // based on the requested HAL version.
680 if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
681 halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
682 // Only support higher HAL version device opened as HAL1.0 device.
683 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800684 *client = new CameraClient(cameraService, tmp, packageName,
685 api1CameraId, facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700686 servicePid);
Ruben Brunkcc776712015-02-17 20:18:47 -0800687 } else {
688 // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
689 ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
690 " opened as HAL %x device", halVersion, deviceVersion,
691 CAMERA_DEVICE_API_VERSION_1_0);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800692 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800693 "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
694 cameraId.string(), deviceVersion, halVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800695 }
696 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800697 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800698}
699
Ruben Brunk6267b532015-04-30 17:44:07 -0700700String8 CameraService::toString(std::set<userid_t> intSet) {
701 String8 s("");
702 bool first = true;
703 for (userid_t i : intSet) {
704 if (first) {
705 s.appendFormat("%d", i);
706 first = false;
707 } else {
708 s.appendFormat(", %d", i);
709 }
710 }
711 return s;
712}
713
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800714int32_t CameraService::mapToInterface(TorchModeStatus status) {
715 int32_t serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
716 switch (status) {
717 case TorchModeStatus::NOT_AVAILABLE:
718 serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
719 break;
720 case TorchModeStatus::AVAILABLE_OFF:
721 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF;
722 break;
723 case TorchModeStatus::AVAILABLE_ON:
724 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON;
725 break;
726 default:
727 ALOGW("Unknown new flash status: %d", status);
728 }
729 return serviceStatus;
730}
731
732CameraService::StatusInternal CameraService::mapToInternal(CameraDeviceStatus status) {
733 StatusInternal serviceStatus = StatusInternal::NOT_PRESENT;
734 switch (status) {
735 case CameraDeviceStatus::NOT_PRESENT:
736 serviceStatus = StatusInternal::NOT_PRESENT;
737 break;
738 case CameraDeviceStatus::PRESENT:
739 serviceStatus = StatusInternal::PRESENT;
740 break;
741 case CameraDeviceStatus::ENUMERATING:
742 serviceStatus = StatusInternal::ENUMERATING;
743 break;
744 default:
745 ALOGW("Unknown new HAL device status: %d", status);
746 }
747 return serviceStatus;
748}
749
750int32_t CameraService::mapToInterface(StatusInternal status) {
751 int32_t serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
752 switch (status) {
753 case StatusInternal::NOT_PRESENT:
754 serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
755 break;
756 case StatusInternal::PRESENT:
757 serviceStatus = ICameraServiceListener::STATUS_PRESENT;
758 break;
759 case StatusInternal::ENUMERATING:
760 serviceStatus = ICameraServiceListener::STATUS_ENUMERATING;
761 break;
762 case StatusInternal::NOT_AVAILABLE:
763 serviceStatus = ICameraServiceListener::STATUS_NOT_AVAILABLE;
764 break;
765 case StatusInternal::UNKNOWN:
766 serviceStatus = ICameraServiceListener::STATUS_UNKNOWN;
767 break;
768 default:
769 ALOGW("Unknown new internal device status: %d", status);
770 }
771 return serviceStatus;
772}
773
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800774Status CameraService::initializeShimMetadata(int cameraId) {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700775 int uid = CameraThreadState::getCallingUid();
Ruben Brunkb2119af2014-05-09 19:57:56 -0700776
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800777 String16 internalPackageName("cameraserver");
Ruben Brunkcc776712015-02-17 20:18:47 -0800778 String8 id = String8::format("%d", cameraId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800779 Status ret = Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800780 sp<Client> tmp = nullptr;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800781 if (!(ret = connectHelper<ICameraClient,Client>(
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800782 sp<ICameraClient>{nullptr}, id, cameraId,
783 static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800784 internalPackageName, uid, USE_CALLING_PID,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700785 API_1, /*shimUpdateOnly*/ true, /*out*/ tmp)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800786 ).isOk()) {
787 ALOGE("%s: Error initializing shim metadata: %s", __FUNCTION__, ret.toString8().string());
Ruben Brunkb2119af2014-05-09 19:57:56 -0700788 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800789 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700790}
791
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800792Status CameraService::getLegacyParametersLazy(int cameraId,
Igor Murashkin65d14b92014-06-17 12:03:20 -0700793 /*out*/
794 CameraParameters* parameters) {
795
796 ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId);
797
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800798 Status ret = Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -0700799
800 if (parameters == NULL) {
801 ALOGE("%s: parameters must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800802 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
Igor Murashkin65d14b92014-06-17 12:03:20 -0700803 }
804
Ruben Brunkcc776712015-02-17 20:18:47 -0800805 String8 id = String8::format("%d", cameraId);
806
807 // Check if we already have parameters
808 {
809 // Scope for service lock
Igor Murashkin65d14b92014-06-17 12:03:20 -0700810 Mutex::Autolock lock(mServiceLock);
Ruben Brunkcc776712015-02-17 20:18:47 -0800811 auto cameraState = getCameraState(id);
812 if (cameraState == nullptr) {
813 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800814 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
815 "Invalid camera ID: %s", id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -0800816 }
817 CameraParameters p = cameraState->getShimParams();
818 if (!p.isEmpty()) {
819 *parameters = p;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800820 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700821 }
822 }
823
Jayant Chowdhary12361932018-08-27 14:46:13 -0700824 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunkcc776712015-02-17 20:18:47 -0800825 ret = initializeShimMetadata(cameraId);
Jayant Chowdhary12361932018-08-27 14:46:13 -0700826 CameraThreadState::restoreCallingIdentity(token);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800827 if (!ret.isOk()) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800828 // Error already logged by callee
829 return ret;
830 }
831
832 // Check for parameters again
833 {
834 // Scope for service lock
835 Mutex::Autolock lock(mServiceLock);
836 auto cameraState = getCameraState(id);
837 if (cameraState == nullptr) {
838 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800839 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
840 "Invalid camera ID: %s", id.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -0700841 }
Ruben Brunkcc776712015-02-17 20:18:47 -0800842 CameraParameters p = cameraState->getShimParams();
843 if (!p.isEmpty()) {
844 *parameters = p;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800845 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700846 }
847 }
848
Ruben Brunkcc776712015-02-17 20:18:47 -0800849 ALOGE("%s: Parameters were not initialized, or were empty. Device may not be present.",
850 __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800851 return STATUS_ERROR(ERROR_INVALID_OPERATION, "Unable to initialize legacy parameters");
Igor Murashkin65d14b92014-06-17 12:03:20 -0700852}
853
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800854// Can camera service trust the caller based on the calling UID?
855static bool isTrustedCallingUid(uid_t uid) {
856 switch (uid) {
Eino-Ville Talvalaaf9d0302016-06-29 14:40:10 -0700857 case AID_MEDIA: // mediaserver
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800858 case AID_CAMERASERVER: // cameraserver
Eino-Ville Talvalaaf9d0302016-06-29 14:40:10 -0700859 case AID_RADIO: // telephony
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800860 return true;
861 default:
862 return false;
863 }
864}
865
Nicholas Sauera3620332019-04-03 14:05:17 -0700866static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
867 PermissionController pc;
868 uid = pc.getPackageUid(packageName, 0);
869 if (uid <= 0) {
870 ALOGE("Unknown package: '%s'", String8(packageName).string());
871 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
872 return BAD_VALUE;
873 }
874
875 if (userId < 0) {
876 ALOGE("Invalid user: %d", userId);
877 dprintf(err, "Invalid user: %d\n", userId);
878 return BAD_VALUE;
879 }
880
881 uid = multiuser_get_uid(userId, uid);
882 return NO_ERROR;
883}
884
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800885Status CameraService::validateConnectLocked(const String8& cameraId,
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700886 const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid,
887 /*out*/int& originalClientPid) const {
Tyler Luu5861a9a2011-10-06 00:00:03 -0500888
Alex Deymo9c2a2c22016-08-25 11:59:14 -0700889#ifdef __BRILLO__
890 UNUSED(clientName8);
891 UNUSED(clientUid);
892 UNUSED(clientPid);
893 UNUSED(originalClientPid);
894#else
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700895 Status allowed = validateClientPermissionsLocked(cameraId, clientName8, clientUid, clientPid,
896 originalClientPid);
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800897 if (!allowed.isOk()) {
Christopher Wileyce761d12016-02-16 10:15:00 -0800898 return allowed;
899 }
Alex Deymo9c2a2c22016-08-25 11:59:14 -0700900#endif // __BRILLO__
Christopher Wileyce761d12016-02-16 10:15:00 -0800901
Jayant Chowdhary12361932018-08-27 14:46:13 -0700902 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800903
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800904 if (!mInitialized) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800905 ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)",
906 callingPid);
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800907 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
908 "No camera HAL module available to open camera device \"%s\"", cameraId.string());
Iliyan Malchev8951a972011-04-14 16:55:59 -0700909 }
910
Ruben Brunkcc776712015-02-17 20:18:47 -0800911 if (getCameraState(cameraId) == nullptr) {
912 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
913 cameraId.string());
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800914 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
915 "No camera device with ID \"%s\" available", cameraId.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700916 }
917
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800918 status_t err = checkIfDeviceIsUsable(cameraId);
919 if (err != NO_ERROR) {
920 switch(err) {
921 case -ENODEV:
922 case -EBUSY:
923 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
924 "No camera device with ID \"%s\" currently available", cameraId.string());
925 default:
926 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
927 "Unknown error connecting to ID \"%s\"", cameraId.string());
928 }
929 }
930 return Status::ok();
Christopher Wiley0039bcf2016-02-05 10:29:50 -0800931}
932
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800933Status CameraService::validateClientPermissionsLocked(const String8& cameraId,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700934 const String8& clientName8, int& clientUid, int& clientPid,
935 /*out*/int& originalClientPid) const {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700936 int callingPid = CameraThreadState::getCallingPid();
937 int callingUid = CameraThreadState::getCallingUid();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700938
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800939 // Check if we can trust clientUid
Mathias Agopian65ab4712010-07-14 17:59:35 -0700940 if (clientUid == USE_CALLING_UID) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800941 clientUid = callingUid;
942 } else if (!isTrustedCallingUid(callingUid)) {
943 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
944 "(don't trust clientUid %d)", callingPid, callingUid, clientUid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800945 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
946 "Untrusted caller (calling PID %d, UID %d) trying to "
947 "forward camera access to camera %s for client %s (PID %d, UID %d)",
948 callingPid, callingUid, cameraId.string(),
949 clientName8.string(), clientUid, clientPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700950 }
951
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800952 // Check if we can trust clientPid
953 if (clientPid == USE_CALLING_PID) {
954 clientPid = callingPid;
955 } else if (!isTrustedCallingUid(callingUid)) {
956 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
957 "(don't trust clientPid %d)", callingPid, callingUid, clientPid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800958 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
959 "Untrusted caller (calling PID %d, UID %d) trying to "
960 "forward camera access to camera %s for client %s (PID %d, UID %d)",
961 callingPid, callingUid, cameraId.string(),
962 clientName8.string(), clientUid, clientPid);
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800963 }
964
965 // If it's not calling from cameraserver, check the permission.
966 if (callingPid != getpid() &&
967 !checkPermission(String16("android.permission.CAMERA"), clientPid, clientUid)) {
968 ALOGE("Permission Denial: can't use the camera pid=%d, uid=%d", clientPid, clientUid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800969 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
970 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" without camera permission",
971 clientName8.string(), clientUid, clientPid, cameraId.string());
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800972 }
973
Svet Ganova453d0d2018-01-11 15:37:58 -0800974 // Make sure the UID is in an active state to use the camera
Svet Ganov7b4ab782018-03-25 12:48:10 -0700975 if (!mUidPolicy->isUidActive(callingUid, String16(clientName8))) {
Varun Shahb42f1eb2019-04-16 14:45:13 -0700976 int32_t procState = mUidPolicy->getProcState(callingUid);
Svet Ganova453d0d2018-01-11 15:37:58 -0800977 ALOGE("Access Denial: can't use the camera from an idle UID pid=%d, uid=%d",
978 clientPid, clientUid);
979 return STATUS_ERROR_FMT(ERROR_DISABLED,
Varun Shahb42f1eb2019-04-16 14:45:13 -0700980 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" from background ("
981 "calling UID %d proc state %" PRId32 ")",
982 clientName8.string(), clientUid, clientPid, cameraId.string(),
983 callingUid, procState);
Svet Ganova453d0d2018-01-11 15:37:58 -0800984 }
985
Michael Grooverd1d435a2018-12-18 17:39:42 -0800986 // If sensor privacy is enabled then prevent access to the camera
987 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
988 ALOGE("Access Denial: cannot use the camera when sensor privacy is enabled");
989 return STATUS_ERROR_FMT(ERROR_DISABLED,
990 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" when sensor privacy "
991 "is enabled", clientName8.string(), clientUid, clientPid, cameraId.string());
992 }
993
Chien-Yu Chen4f3d6202016-03-22 10:50:23 -0700994 // Only use passed in clientPid to check permission. Use calling PID as the client PID that's
995 // connected to camera service directly.
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700996 originalClientPid = clientPid;
Chien-Yu Chen4f3d6202016-03-22 10:50:23 -0700997 clientPid = callingPid;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700998
Ruben Brunk6267b532015-04-30 17:44:07 -0700999 userid_t clientUserId = multiuser_get_user_id(clientUid);
Wu-cheng Lia3355432011-05-20 14:54:25 +08001000
Ruben Brunka8ca9152015-04-07 14:23:40 -07001001 // Only allow clients who are being used by the current foreground device user, unless calling
Jayant Chowdhary8ec41c12019-02-21 20:17:22 -08001002 // from our own process OR the caller is using the cameraserver's HIDL interface.
1003 if (!hardware::IPCThreadState::self()->isServingCall() && callingPid != getpid() &&
1004 (mAllowedUsers.find(clientUserId) == mAllowedUsers.end())) {
Ruben Brunk6267b532015-04-30 17:44:07 -07001005 ALOGE("CameraService::connect X (PID %d) rejected (cannot connect from "
1006 "device user %d, currently allowed device users: %s)", callingPid, clientUserId,
1007 toString(mAllowedUsers).string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001008 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1009 "Callers from device user %d are not currently allowed to connect to camera \"%s\"",
1010 clientUserId, cameraId.string());
Ruben Brunk36597b22015-03-20 22:15:57 -07001011 }
1012
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001013 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001014}
1015
1016status_t CameraService::checkIfDeviceIsUsable(const String8& cameraId) const {
1017 auto cameraState = getCameraState(cameraId);
Jayant Chowdhary12361932018-08-27 14:46:13 -07001018 int callingPid = CameraThreadState::getCallingPid();
Ruben Brunkcc776712015-02-17 20:18:47 -08001019 if (cameraState == nullptr) {
1020 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
1021 cameraId.string());
1022 return -ENODEV;
1023 }
1024
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001025 StatusInternal currentStatus = cameraState->getStatus();
1026 if (currentStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001027 ALOGE("CameraService::connect X (PID %d) rejected (camera %s is not connected)",
1028 callingPid, cameraId.string());
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001029 return -ENODEV;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001030 } else if (currentStatus == StatusInternal::ENUMERATING) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001031 ALOGE("CameraService::connect X (PID %d) rejected, (camera %s is initializing)",
1032 callingPid, cameraId.string());
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001033 return -EBUSY;
Igor Murashkincba2c162013-03-20 15:56:31 -07001034 }
Igor Murashkincba2c162013-03-20 15:56:31 -07001035
Ruben Brunkcc776712015-02-17 20:18:47 -08001036 return NO_ERROR;
Igor Murashkine6800ce2013-03-04 17:25:57 -08001037}
1038
Ruben Brunkcc776712015-02-17 20:18:47 -08001039void CameraService::finishConnectLocked(const sp<BasicClient>& client,
1040 const CameraService::DescriptorPtr& desc) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001041
Ruben Brunkcc776712015-02-17 20:18:47 -08001042 // Make a descriptor for the incoming client
1043 auto clientDescriptor = CameraService::CameraClientManager::makeClientDescriptor(client, desc);
1044 auto evicted = mActiveClientManager.addAndEvict(clientDescriptor);
1045
1046 logConnected(desc->getKey(), static_cast<int>(desc->getOwnerId()),
1047 String8(client->getPackageName()));
1048
1049 if (evicted.size() > 0) {
1050 // This should never happen - clients should already have been removed in disconnect
1051 for (auto& i : evicted) {
1052 ALOGE("%s: Invalid state: Client for camera %s was not removed in disconnect",
1053 __FUNCTION__, i->getKey().string());
1054 }
1055
1056 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, clients not evicted properly",
1057 __FUNCTION__);
1058 }
Eino-Ville Talvala24901c82015-09-04 14:15:58 -07001059
1060 // And register a death notification for the client callback. Do
1061 // this last to avoid Binder policy where a nested Binder
1062 // transaction might be pre-empted to service the client death
1063 // notification if the client process dies before linkToDeath is
1064 // invoked.
1065 sp<IBinder> remoteCallback = client->getRemote();
1066 if (remoteCallback != nullptr) {
1067 remoteCallback->linkToDeath(this);
1068 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001069}
1070
1071status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clientPid,
1072 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
1073 /*out*/
1074 sp<BasicClient>* client,
1075 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001076 ATRACE_CALL();
Ruben Brunkcc776712015-02-17 20:18:47 -08001077 status_t ret = NO_ERROR;
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001078 std::vector<DescriptorPtr> evictedClients;
Ruben Brunkcc776712015-02-17 20:18:47 -08001079 DescriptorPtr clientDescriptor;
1080 {
1081 if (effectiveApiLevel == API_1) {
1082 // If we are using API1, any existing client for this camera ID with the same remote
1083 // should be returned rather than evicted to allow MediaRecorder to work properly.
1084
1085 auto current = mActiveClientManager.get(cameraId);
1086 if (current != nullptr) {
1087 auto clientSp = current->getValue();
1088 if (clientSp.get() != nullptr) { // should never be needed
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07001089 if (!clientSp->canCastToApiClient(effectiveApiLevel)) {
1090 ALOGW("CameraService connect called from same client, but with a different"
1091 " API level, evicting prior client...");
1092 } else if (clientSp->getRemote() == remoteCallback) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001093 ALOGI("CameraService::connect X (PID %d) (second call from same"
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07001094 " app binder, returning the same client)", clientPid);
Ruben Brunkcc776712015-02-17 20:18:47 -08001095 *client = clientSp;
1096 return NO_ERROR;
1097 }
1098 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001099 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001100 }
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +08001101
Ruben Brunkcc776712015-02-17 20:18:47 -08001102 // Get current active client PIDs
1103 std::vector<int> ownerPids(mActiveClientManager.getAllOwners());
1104 ownerPids.push_back(clientPid);
Igor Murashkine6800ce2013-03-04 17:25:57 -08001105
Emilian Peev8131a262017-02-01 12:33:43 +00001106 std::vector<int> priorityScores(ownerPids.size());
1107 std::vector<int> states(ownerPids.size());
Igor Murashkine6800ce2013-03-04 17:25:57 -08001108
Emilian Peev8131a262017-02-01 12:33:43 +00001109 // Get priority scores of all active PIDs
1110 status_t err = ProcessInfoService::getProcessStatesScoresFromPids(
1111 ownerPids.size(), &ownerPids[0], /*out*/&states[0],
1112 /*out*/&priorityScores[0]);
1113 if (err != OK) {
1114 ALOGE("%s: Priority score query failed: %d",
1115 __FUNCTION__, err);
1116 return err;
1117 }
Ruben Brunkb2119af2014-05-09 19:57:56 -07001118
Ruben Brunkcc776712015-02-17 20:18:47 -08001119 // Update all active clients' priorities
Emilian Peev8131a262017-02-01 12:33:43 +00001120 std::map<int,resource_policy::ClientPriority> pidToPriorityMap;
Ruben Brunkcc776712015-02-17 20:18:47 -08001121 for (size_t i = 0; i < ownerPids.size() - 1; i++) {
Emilian Peev8131a262017-02-01 12:33:43 +00001122 pidToPriorityMap.emplace(ownerPids[i],
1123 resource_policy::ClientPriority(priorityScores[i], states[i]));
Ruben Brunkcc776712015-02-17 20:18:47 -08001124 }
1125 mActiveClientManager.updatePriorities(pidToPriorityMap);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001126
Ruben Brunkcc776712015-02-17 20:18:47 -08001127 // Get state for the given cameraId
1128 auto state = getCameraState(cameraId);
1129 if (state == nullptr) {
1130 ALOGE("CameraService::connect X (PID %d) rejected (no camera device with ID %s)",
1131 clientPid, cameraId.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001132 // Should never get here because validateConnectLocked should have errored out
Zhijun Heb10cdad2014-06-16 16:38:35 -07001133 return BAD_VALUE;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001134 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001135
1136 // Make descriptor for incoming client
Shuzhen Wang2db86ff2018-04-25 01:11:17 +00001137 clientDescriptor = CameraClientManager::makeClientDescriptor(cameraId,
Ruben Brunkcc776712015-02-17 20:18:47 -08001138 sp<BasicClient>{nullptr}, static_cast<int32_t>(state->getCost()),
1139 state->getConflicting(),
Emilian Peev8131a262017-02-01 12:33:43 +00001140 priorityScores[priorityScores.size() - 1],
1141 clientPid,
1142 states[states.size() - 1]);
Ruben Brunkcc776712015-02-17 20:18:47 -08001143
1144 // Find clients that would be evicted
1145 auto evicted = mActiveClientManager.wouldEvict(clientDescriptor);
1146
1147 // If the incoming client was 'evicted,' higher priority clients have the camera in the
1148 // background, so we cannot do evictions
1149 if (std::find(evicted.begin(), evicted.end(), clientDescriptor) != evicted.end()) {
1150 ALOGE("CameraService::connect X (PID %d) rejected (existing client(s) with higher"
1151 " priority).", clientPid);
1152
1153 sp<BasicClient> clientSp = clientDescriptor->getValue();
1154 String8 curTime = getFormattedCurrentTime();
1155 auto incompatibleClients =
1156 mActiveClientManager.getIncompatibleClients(clientDescriptor);
1157
1158 String8 msg = String8::format("%s : DENIED connect device %s client for package %s "
Emilian Peev8131a262017-02-01 12:33:43 +00001159 "(PID %d, score %d state %d) due to eviction policy", curTime.string(),
Ruben Brunkcc776712015-02-17 20:18:47 -08001160 cameraId.string(), packageName.string(), clientPid,
Emilian Peev8131a262017-02-01 12:33:43 +00001161 priorityScores[priorityScores.size() - 1],
1162 states[states.size() - 1]);
Ruben Brunkcc776712015-02-17 20:18:47 -08001163
1164 for (auto& i : incompatibleClients) {
1165 msg.appendFormat("\n - Blocked by existing device %s client for package %s"
Emilian Peev8131a262017-02-01 12:33:43 +00001166 "(PID %" PRId32 ", score %" PRId32 ", state %" PRId32 ")",
1167 i->getKey().string(),
1168 String8{i->getValue()->getPackageName()}.string(),
1169 i->getOwnerId(), i->getPriority().getScore(),
1170 i->getPriority().getState());
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07001171 ALOGE(" Conflicts with: Device %s, client package %s (PID %"
Emilian Peev8131a262017-02-01 12:33:43 +00001172 PRId32 ", score %" PRId32 ", state %" PRId32 ")", i->getKey().string(),
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07001173 String8{i->getValue()->getPackageName()}.string(), i->getOwnerId(),
Emilian Peev8131a262017-02-01 12:33:43 +00001174 i->getPriority().getScore(), i->getPriority().getState());
Ruben Brunkcc776712015-02-17 20:18:47 -08001175 }
1176
1177 // Log the client's attempt
Ruben Brunka8ca9152015-04-07 14:23:40 -07001178 Mutex::Autolock l(mLogLock);
Ruben Brunkcc776712015-02-17 20:18:47 -08001179 mEventLog.add(msg);
1180
1181 return -EBUSY;
1182 }
1183
1184 for (auto& i : evicted) {
1185 sp<BasicClient> clientSp = i->getValue();
1186 if (clientSp.get() == nullptr) {
1187 ALOGE("%s: Invalid state: Null client in active client list.", __FUNCTION__);
1188
1189 // TODO: Remove this
1190 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, null client in active list",
1191 __FUNCTION__);
1192 mActiveClientManager.remove(i);
1193 continue;
1194 }
1195
1196 ALOGE("CameraService::connect evicting conflicting client for camera ID %s",
1197 i->getKey().string());
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001198 evictedClients.push_back(i);
Ruben Brunkcc776712015-02-17 20:18:47 -08001199
Ruben Brunkcc776712015-02-17 20:18:47 -08001200 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07001201 logEvent(String8::format("EVICT device %s client held by package %s (PID"
Emilian Peev8131a262017-02-01 12:33:43 +00001202 " %" PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted by device %s client for"
1203 " package %s (PID %d, score %" PRId32 ", state %" PRId32 ")",
Ruben Brunkcc776712015-02-17 20:18:47 -08001204 i->getKey().string(), String8{clientSp->getPackageName()}.string(),
Emilian Peev8131a262017-02-01 12:33:43 +00001205 i->getOwnerId(), i->getPriority().getScore(),
1206 i->getPriority().getState(), cameraId.string(),
Ruben Brunkcc776712015-02-17 20:18:47 -08001207 packageName.string(), clientPid,
Emilian Peev8131a262017-02-01 12:33:43 +00001208 priorityScores[priorityScores.size() - 1],
1209 states[states.size() - 1]));
Ruben Brunkcc776712015-02-17 20:18:47 -08001210
1211 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001212 clientSp->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -08001213 CaptureResultExtras());
Zhijun Heb10cdad2014-06-16 16:38:35 -07001214 }
Ruben Brunkb2119af2014-05-09 19:57:56 -07001215 }
1216
Ruben Brunkcc776712015-02-17 20:18:47 -08001217 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1218 // other clients from connecting in mServiceLockWrapper if held
1219 mServiceLock.unlock();
1220
1221 // Clear caller identity temporarily so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -07001222 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunkcc776712015-02-17 20:18:47 -08001223
1224 // Destroy evicted clients
1225 for (auto& i : evictedClients) {
1226 // Disconnect is blocking, and should only have returned when HAL has cleaned up
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001227 i->getValue()->disconnect(); // Clients will remove themselves from the active client list
Ruben Brunkcc776712015-02-17 20:18:47 -08001228 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001229
Jayant Chowdhary12361932018-08-27 14:46:13 -07001230 CameraThreadState::restoreCallingIdentity(token);
Ruben Brunkcc776712015-02-17 20:18:47 -08001231
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001232 for (const auto& i : evictedClients) {
1233 ALOGV("%s: Waiting for disconnect to complete for client for device %s (PID %" PRId32 ")",
1234 __FUNCTION__, i->getKey().string(), i->getOwnerId());
1235 ret = mActiveClientManager.waitUntilRemoved(i, DEFAULT_DISCONNECT_TIMEOUT_NS);
1236 if (ret == TIMED_OUT) {
1237 ALOGE("%s: Timed out waiting for client for device %s to disconnect, "
1238 "current clients:\n%s", __FUNCTION__, i->getKey().string(),
1239 mActiveClientManager.toString().string());
1240 return -EBUSY;
1241 }
1242 if (ret != NO_ERROR) {
1243 ALOGE("%s: Received error waiting for client for device %s to disconnect: %s (%d), "
1244 "current clients:\n%s", __FUNCTION__, i->getKey().string(), strerror(-ret),
1245 ret, mActiveClientManager.toString().string());
1246 return ret;
1247 }
1248 }
1249
1250 evictedClients.clear();
1251
Ruben Brunkcc776712015-02-17 20:18:47 -08001252 // Once clients have been disconnected, relock
1253 mServiceLock.lock();
1254
1255 // Check again if the device was unplugged or something while we weren't holding mServiceLock
1256 if ((ret = checkIfDeviceIsUsable(cameraId)) != NO_ERROR) {
1257 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -07001258 }
1259
Ruben Brunkcc776712015-02-17 20:18:47 -08001260 *partial = clientDescriptor;
1261 return NO_ERROR;
Ruben Brunkb2119af2014-05-09 19:57:56 -07001262}
1263
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001264Status CameraService::connect(
Igor Murashkine6800ce2013-03-04 17:25:57 -08001265 const sp<ICameraClient>& cameraClient,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001266 int api1CameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001267 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001268 int clientUid,
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001269 int clientPid,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001270 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001271 sp<ICamera>* device) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001272
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001273 ATRACE_CALL();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001274 Status ret = Status::ok();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001275
1276 String8 id = cameraIdIntToStr(api1CameraId);
Ruben Brunkcc776712015-02-17 20:18:47 -08001277 sp<Client> client = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001278 ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001279 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001280 /*shimUpdateOnly*/ false, /*out*/client);
Igor Murashkine6800ce2013-03-04 17:25:57 -08001281
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001282 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001283 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001284 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001285 return ret;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001286 }
1287
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001288 *device = client;
1289 return ret;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001290}
1291
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001292Status CameraService::connectLegacy(
Zhijun Heb10cdad2014-06-16 16:38:35 -07001293 const sp<ICameraClient>& cameraClient,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001294 int api1CameraId, int halVersion,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001295 const String16& clientPackageName,
Zhijun Heb10cdad2014-06-16 16:38:35 -07001296 int clientUid,
1297 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001298 sp<ICamera>* device) {
Zhijun Heb10cdad2014-06-16 16:38:35 -07001299
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001300 ATRACE_CALL();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001301 String8 id = cameraIdIntToStr(api1CameraId);
Zhijun Heb10cdad2014-06-16 16:38:35 -07001302
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001303 Status ret = Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001304 sp<Client> client = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001305 ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId, halVersion,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001306 clientPackageName, clientUid, USE_CALLING_PID, API_1, /*shimUpdateOnly*/ false,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001307 /*out*/client);
Zhijun Heb10cdad2014-06-16 16:38:35 -07001308
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001309 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001310 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001311 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001312 return ret;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001313 }
1314
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001315 *device = client;
1316 return ret;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001317}
1318
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001319bool CameraService::shouldRejectHiddenCameraConnection(const String8 & cameraId) {
1320 // If the thread serving this call is not a hwbinder thread and the caller
1321 // isn't the cameraserver itself, and the camera id being requested is to be
1322 // publically hidden, we should reject the connection.
1323 if (!hardware::IPCThreadState::self()->isServingCall() &&
1324 CameraThreadState::getCallingPid() != getpid() &&
1325 mCameraProviderManager->isPublicallyHiddenSecureCamera(cameraId.c_str())) {
1326 return true;
1327 }
1328 return false;
1329}
1330
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001331Status CameraService::connectDevice(
1332 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001333 const String16& cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001334 const String16& clientPackageName,
Ruben Brunkcc776712015-02-17 20:18:47 -08001335 int clientUid,
1336 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001337 sp<hardware::camera2::ICameraDeviceUser>* device) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001338
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001339 ATRACE_CALL();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001340 Status ret = Status::ok();
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001341 String8 id = String8(cameraId);
Ruben Brunkcc776712015-02-17 20:18:47 -08001342 sp<CameraDeviceClient> client = nullptr;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001343
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001344 ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001345 /*api1CameraId*/-1,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001346 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001347 clientUid, USE_CALLING_PID, API_2, /*shimUpdateOnly*/ false, /*out*/client);
Ruben Brunkcc776712015-02-17 20:18:47 -08001348
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001349 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001350 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001351 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001352 return ret;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001353 }
1354
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001355 *device = client;
1356 return ret;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001357}
1358
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001359template<class CALLBACK, class CLIENT>
1360Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001361 int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001362 int clientPid, apiLevel effectiveApiLevel, bool shimUpdateOnly,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001363 /*out*/sp<CLIENT>& device) {
1364 binder::Status ret = binder::Status::ok();
1365
1366 String8 clientName8(clientPackageName);
1367
1368 int originalClientPid = 0;
1369
1370 ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
1371 "Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
1372 (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
1373 static_cast<int>(effectiveApiLevel));
1374
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001375 if (shouldRejectHiddenCameraConnection(cameraId)) {
1376 ALOGW("Attempting to connect to system-only camera id %s, connection rejected",
1377 cameraId.c_str());
1378 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1379 "No camera device with ID \"%s\" currently available",
1380 cameraId.string());
1381
1382 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001383 sp<CLIENT> client = nullptr;
1384 {
1385 // Acquire mServiceLock and prevent other clients from connecting
1386 std::unique_ptr<AutoConditionLock> lock =
1387 AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
1388
1389 if (lock == nullptr) {
1390 ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
1391 , clientPid);
1392 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1393 "Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
1394 cameraId.string(), clientName8.string(), clientPid);
1395 }
1396
1397 // Enforce client permissions and do basic sanity checks
1398 if(!(ret = validateConnectLocked(cameraId, clientName8,
1399 /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
1400 return ret;
1401 }
1402
1403 // Check the shim parameters after acquiring lock, if they have already been updated and
1404 // we were doing a shim update, return immediately
1405 if (shimUpdateOnly) {
1406 auto cameraState = getCameraState(cameraId);
1407 if (cameraState != nullptr) {
1408 if (!cameraState->getShimParams().isEmpty()) return ret;
1409 }
1410 }
1411
1412 status_t err;
1413
1414 sp<BasicClient> clientTmp = nullptr;
1415 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
1416 if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
1417 IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
1418 /*out*/&partial)) != NO_ERROR) {
1419 switch (err) {
1420 case -ENODEV:
1421 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1422 "No camera device with ID \"%s\" currently available",
1423 cameraId.string());
1424 case -EBUSY:
1425 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1426 "Higher-priority client using camera, ID \"%s\" currently unavailable",
1427 cameraId.string());
1428 default:
1429 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1430 "Unexpected error %s (%d) opening camera \"%s\"",
1431 strerror(-err), err, cameraId.string());
1432 }
1433 }
1434
1435 if (clientTmp.get() != nullptr) {
1436 // Handle special case for API1 MediaRecorder where the existing client is returned
1437 device = static_cast<CLIENT*>(clientTmp.get());
1438 return ret;
1439 }
1440
1441 // give flashlight a chance to close devices if necessary.
1442 mFlashlight->prepareDeviceOpen(cameraId);
1443
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001444 int facing = -1;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001445 int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
Eino-Ville Talvala6963d0a2017-01-31 13:00:34 -08001446 if (facing == -1) {
1447 ALOGE("%s: Unable to get camera device \"%s\" facing", __FUNCTION__, cameraId.string());
1448 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1449 "Unable to get camera device \"%s\" facing", cameraId.string());
1450 }
1451
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001452 sp<BasicClient> tmp = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001453 if(!(ret = makeClient(this, cameraCb, clientPackageName,
1454 cameraId, api1CameraId, facing,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001455 clientPid, clientUid, getpid(),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001456 halVersion, deviceVersion, effectiveApiLevel,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001457 /*out*/&tmp)).isOk()) {
1458 return ret;
1459 }
1460 client = static_cast<CLIENT*>(tmp.get());
1461
1462 LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
1463 __FUNCTION__);
1464
Emilian Peevbd8c5032018-02-14 23:05:40 +00001465 err = client->initialize(mCameraProviderManager, mMonitorTags);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001466 if (err != OK) {
1467 ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001468 // Errors could be from the HAL module open call or from AppOpsManager
1469 switch(err) {
1470 case BAD_VALUE:
1471 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1472 "Illegal argument to HAL module for camera \"%s\"", cameraId.string());
1473 case -EBUSY:
1474 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1475 "Camera \"%s\" is already open", cameraId.string());
1476 case -EUSERS:
1477 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1478 "Too many cameras already open, cannot open camera \"%s\"",
1479 cameraId.string());
1480 case PERMISSION_DENIED:
1481 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1482 "No permission to open camera \"%s\"", cameraId.string());
1483 case -EACCES:
1484 return STATUS_ERROR_FMT(ERROR_DISABLED,
1485 "Camera \"%s\" disabled by policy", cameraId.string());
1486 case -ENODEV:
1487 default:
1488 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1489 "Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
1490 strerror(-err), err);
1491 }
1492 }
1493
1494 // Update shim paremeters for legacy clients
1495 if (effectiveApiLevel == API_1) {
1496 // Assume we have always received a Client subclass for API1
1497 sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
1498 String8 rawParams = shimClient->getParameters();
1499 CameraParameters params(rawParams);
1500
1501 auto cameraState = getCameraState(cameraId);
1502 if (cameraState != nullptr) {
1503 cameraState->setShimParams(params);
1504 } else {
1505 ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
1506 __FUNCTION__, cameraId.string());
1507 }
1508 }
1509
1510 if (shimUpdateOnly) {
1511 // If only updating legacy shim parameters, immediately disconnect client
1512 mServiceLock.unlock();
1513 client->disconnect();
1514 mServiceLock.lock();
1515 } else {
1516 // Otherwise, add client to active clients list
1517 finishConnectLocked(client, partial);
1518 }
1519 } // lock is destroyed, allow further connect calls
1520
1521 // Important: release the mutex here so the client can call back into the service from its
1522 // destructor (can be at the end of the call)
1523 device = client;
1524 return ret;
1525}
1526
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001527Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001528 const sp<IBinder>& clientBinder) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001529 Mutex::Autolock lock(mServiceLock);
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001530
1531 ATRACE_CALL();
Ruben Brunk99e69712015-05-26 17:25:07 -07001532 if (enabled && clientBinder == nullptr) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001533 ALOGE("%s: torch client binder is NULL", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001534 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
1535 "Torch client Binder is null");
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001536 }
1537
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001538 String8 id = String8(cameraId.string());
Jayant Chowdhary12361932018-08-27 14:46:13 -07001539 int uid = CameraThreadState::getCallingUid();
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001540
1541 // verify id is valid.
Ruben Brunkcc776712015-02-17 20:18:47 -08001542 auto state = getCameraState(id);
1543 if (state == nullptr) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07001544 ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001545 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1546 "Camera ID \"%s\" is a not valid camera ID", id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -08001547 }
1548
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001549 StatusInternal cameraStatus = state->getStatus();
1550 if (cameraStatus != StatusInternal::PRESENT &&
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001551 cameraStatus != StatusInternal::NOT_AVAILABLE) {
1552 ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001553 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1554 "Camera ID \"%s\" is a not valid camera ID", id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001555 }
1556
1557 {
1558 Mutex::Autolock al(mTorchStatusMutex);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001559 TorchModeStatus status;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001560 status_t err = getTorchStatusLocked(id, &status);
1561 if (err != OK) {
1562 if (err == NAME_NOT_FOUND) {
1563 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1564 "Camera \"%s\" does not have a flash unit", id.string());
1565 }
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001566 ALOGE("%s: getting current torch status failed for camera %s",
1567 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001568 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1569 "Error updating torch status for camera \"%s\": %s (%d)", id.string(),
1570 strerror(-err), err);
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001571 }
1572
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001573 if (status == TorchModeStatus::NOT_AVAILABLE) {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001574 if (cameraStatus == StatusInternal::NOT_AVAILABLE) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001575 ALOGE("%s: torch mode of camera %s is not available because "
1576 "camera is in use", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001577 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1578 "Torch for camera \"%s\" is not available due to an existing camera user",
1579 id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001580 } else {
1581 ALOGE("%s: torch mode of camera %s is not available due to "
1582 "insufficient resources", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001583 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1584 "Torch for camera \"%s\" is not available due to insufficient resources",
1585 id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001586 }
1587 }
1588 }
1589
Ruben Brunk99e69712015-05-26 17:25:07 -07001590 {
1591 // Update UID map - this is used in the torch status changed callbacks, so must be done
1592 // before setTorchMode
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001593 Mutex::Autolock al(mTorchUidMapMutex);
Ruben Brunk99e69712015-05-26 17:25:07 -07001594 if (mTorchUidMap.find(id) == mTorchUidMap.end()) {
1595 mTorchUidMap[id].first = uid;
1596 mTorchUidMap[id].second = uid;
1597 } else {
1598 // Set the pending UID
1599 mTorchUidMap[id].first = uid;
1600 }
1601 }
1602
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001603 status_t err = mFlashlight->setTorchMode(id, enabled);
Ruben Brunk99e69712015-05-26 17:25:07 -07001604
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001605 if (err != OK) {
1606 int32_t errorCode;
1607 String8 msg;
1608 switch (err) {
1609 case -ENOSYS:
1610 msg = String8::format("Camera \"%s\" has no flashlight",
1611 id.string());
1612 errorCode = ERROR_ILLEGAL_ARGUMENT;
1613 break;
1614 default:
1615 msg = String8::format(
1616 "Setting torch mode of camera \"%s\" to %d failed: %s (%d)",
1617 id.string(), enabled, strerror(-err), err);
1618 errorCode = ERROR_INVALID_OPERATION;
1619 }
1620 ALOGE("%s: %s", __FUNCTION__, msg.string());
1621 return STATUS_ERROR(errorCode, msg.string());
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001622 }
1623
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001624 {
1625 // update the link to client's death
1626 Mutex::Autolock al(mTorchClientMapMutex);
1627 ssize_t index = mTorchClientMap.indexOfKey(id);
1628 if (enabled) {
1629 if (index == NAME_NOT_FOUND) {
1630 mTorchClientMap.add(id, clientBinder);
1631 } else {
Ruben Brunk99e69712015-05-26 17:25:07 -07001632 mTorchClientMap.valueAt(index)->unlinkToDeath(this);
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001633 mTorchClientMap.replaceValueAt(index, clientBinder);
1634 }
1635 clientBinder->linkToDeath(this);
1636 } else if (index != NAME_NOT_FOUND) {
Ruben Brunk99e69712015-05-26 17:25:07 -07001637 mTorchClientMap.valueAt(index)->unlinkToDeath(this);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001638 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001639 }
1640
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001641 return Status::ok();
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001642}
1643
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001644Status CameraService::notifySystemEvent(int32_t eventId,
1645 const std::vector<int32_t>& args) {
Jeongik Chaaa5e64c2018-11-17 05:08:04 +09001646 const int pid = CameraThreadState::getCallingPid();
1647 const int selfPid = getpid();
1648
1649 // Permission checks
1650 if (pid != selfPid) {
1651 // Ensure we're being called by system_server, or similar process with
1652 // permissions to notify the camera service about system events
1653 if (!checkCallingPermission(
1654 String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) {
1655 const int uid = CameraThreadState::getCallingUid();
1656 ALOGE("Permission Denial: cannot send updates to camera service about system"
1657 " events from pid=%d, uid=%d", pid, uid);
1658 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
Jeongik Chaaa1b8152018-11-21 10:02:25 +09001659 "No permission to send updates to camera service about system events"
1660 " from pid=%d, uid=%d", pid, uid);
Jeongik Chaaa5e64c2018-11-17 05:08:04 +09001661 }
1662 }
1663
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001664 ATRACE_CALL();
1665
Ruben Brunk36597b22015-03-20 22:15:57 -07001666 switch(eventId) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001667 case ICameraService::EVENT_USER_SWITCHED: {
Michael Grooverd1d435a2018-12-18 17:39:42 -08001668 // Try to register for UID and sensor privacy policy updates, in case we're recovering
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07001669 // from a system server crash
1670 mUidPolicy->registerSelf();
Michael Grooverd1d435a2018-12-18 17:39:42 -08001671 mSensorPrivacyPolicy->registerSelf();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001672 doUserSwitch(/*newUserIds*/ args);
Ruben Brunk36597b22015-03-20 22:15:57 -07001673 break;
1674 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001675 case ICameraService::EVENT_NONE:
Ruben Brunk36597b22015-03-20 22:15:57 -07001676 default: {
1677 ALOGW("%s: Received invalid system event from system_server: %d", __FUNCTION__,
1678 eventId);
1679 break;
1680 }
1681 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001682 return Status::ok();
Ruben Brunk36597b22015-03-20 22:15:57 -07001683}
1684
Emilian Peev53722fa2019-02-22 17:47:20 -08001685void CameraService::notifyMonitoredUids() {
1686 Mutex::Autolock lock(mStatusListenerLock);
1687
1688 for (const auto& it : mListenerList) {
1689 auto ret = it.second->getListener()->onCameraAccessPrioritiesChanged();
1690 if (!ret.isOk()) {
1691 ALOGE("%s: Failed to trigger permission callback: %d", __FUNCTION__,
1692 ret.exceptionCode());
1693 }
1694 }
1695}
1696
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001697Status CameraService::notifyDeviceStateChange(int64_t newState) {
1698 const int pid = CameraThreadState::getCallingPid();
1699 const int selfPid = getpid();
1700
1701 // Permission checks
1702 if (pid != selfPid) {
1703 // Ensure we're being called by system_server, or similar process with
1704 // permissions to notify the camera service about system events
1705 if (!checkCallingPermission(
1706 String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) {
1707 const int uid = CameraThreadState::getCallingUid();
1708 ALOGE("Permission Denial: cannot send updates to camera service about device"
1709 " state changes from pid=%d, uid=%d", pid, uid);
1710 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1711 "No permission to send updates to camera service about device state"
1712 " changes from pid=%d, uid=%d", pid, uid);
1713 }
1714 }
1715
1716 ATRACE_CALL();
1717
1718 using hardware::camera::provider::V2_5::DeviceState;
1719 hardware::hidl_bitfield<DeviceState> newDeviceState{};
1720 if (newState & ICameraService::DEVICE_STATE_BACK_COVERED) {
1721 newDeviceState |= DeviceState::BACK_COVERED;
1722 }
1723 if (newState & ICameraService::DEVICE_STATE_FRONT_COVERED) {
1724 newDeviceState |= DeviceState::FRONT_COVERED;
1725 }
1726 if (newState & ICameraService::DEVICE_STATE_FOLDED) {
1727 newDeviceState |= DeviceState::FOLDED;
1728 }
1729 // Only map vendor bits directly
1730 uint64_t vendorBits = static_cast<uint64_t>(newState) & 0xFFFFFFFF00000000l;
1731 newDeviceState |= vendorBits;
1732
1733 ALOGV("%s: New device state 0x%" PRIx64, __FUNCTION__, newDeviceState);
1734 Mutex::Autolock l(mServiceLock);
1735 mCameraProviderManager->notifyDeviceStateChange(newDeviceState);
1736
1737 return Status::ok();
1738}
1739
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001740Status CameraService::addListener(const sp<ICameraServiceListener>& listener,
1741 /*out*/
1742 std::vector<hardware::CameraStatus> *cameraStatuses) {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001743 return addListenerHelper(listener, cameraStatuses);
1744}
1745
1746Status CameraService::addListenerHelper(const sp<ICameraServiceListener>& listener,
1747 /*out*/
1748 std::vector<hardware::CameraStatus> *cameraStatuses,
1749 bool isVendorListener) {
1750
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001751 ATRACE_CALL();
1752
Igor Murashkinbfc99152013-02-27 12:55:20 -08001753 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
Igor Murashkin634a5152013-02-20 17:15:11 -08001754
Ruben Brunk3450ba72015-06-16 11:00:37 -07001755 if (listener == nullptr) {
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001756 ALOGE("%s: Listener must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001757 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to addListener");
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001758 }
1759
Igor Murashkinbfc99152013-02-27 12:55:20 -08001760 Mutex::Autolock lock(mServiceLock);
1761
Ruben Brunkcc776712015-02-17 20:18:47 -08001762 {
1763 Mutex::Autolock lock(mStatusListenerLock);
Emilian Peev53722fa2019-02-22 17:47:20 -08001764 for (const auto &it : mListenerList) {
1765 if (IInterface::asBinder(it.second->getListener()) == IInterface::asBinder(listener)) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001766 ALOGW("%s: Tried to add listener %p which was already subscribed",
1767 __FUNCTION__, listener.get());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001768 return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
Ruben Brunkcc776712015-02-17 20:18:47 -08001769 }
Igor Murashkinbfc99152013-02-27 12:55:20 -08001770 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001771
Emilian Peev53722fa2019-02-22 17:47:20 -08001772 auto clientUid = CameraThreadState::getCallingUid();
1773 sp<ServiceListener> serviceListener = new ServiceListener(this, listener, clientUid);
1774 auto ret = serviceListener->initialize();
1775 if (ret != NO_ERROR) {
1776 String8 msg = String8::format("Failed to initialize service listener: %s (%d)",
1777 strerror(-ret), ret);
1778 ALOGE("%s: %s", __FUNCTION__, msg.string());
1779 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1780 }
1781 mListenerList.emplace_back(isVendorListener, serviceListener);
1782 mUidPolicy->registerMonitorUid(clientUid);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001783 }
1784
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001785 /* Collect current devices and status */
Igor Murashkincba2c162013-03-20 15:56:31 -07001786 {
Ruben Brunkcc776712015-02-17 20:18:47 -08001787 Mutex::Autolock lock(mCameraStatesLock);
1788 for (auto& i : mCameraStates) {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001789 if (!isVendorListener &&
1790 mCameraProviderManager->isPublicallyHiddenSecureCamera(i.first.c_str())) {
1791 ALOGV("Cannot add public listener for hidden system-only %s for pid %d",
1792 i.first.c_str(), CameraThreadState::getCallingPid());
1793 continue;
1794 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001795 cameraStatuses->emplace_back(i.first, mapToInterface(i.second->getStatus()));
Igor Murashkincba2c162013-03-20 15:56:31 -07001796 }
1797 }
1798
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001799 /*
1800 * Immediately signal current torch status to this listener only
1801 * This may be a subset of all the devices, so don't include it in the response directly
1802 */
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001803 {
1804 Mutex::Autolock al(mTorchStatusMutex);
1805 for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001806 String16 id = String16(mTorchStatusMap.keyAt(i).string());
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001807 listener->onTorchStatusChanged(mapToInterface(mTorchStatusMap.valueAt(i)), id);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001808 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001809 }
1810
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001811 return Status::ok();
Igor Murashkinbfc99152013-02-27 12:55:20 -08001812}
Ruben Brunkcc776712015-02-17 20:18:47 -08001813
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001814Status CameraService::removeListener(const sp<ICameraServiceListener>& listener) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001815 ATRACE_CALL();
1816
Igor Murashkinbfc99152013-02-27 12:55:20 -08001817 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
1818
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001819 if (listener == 0) {
1820 ALOGE("%s: Listener must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001821 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to removeListener");
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001822 }
1823
Igor Murashkinbfc99152013-02-27 12:55:20 -08001824 Mutex::Autolock lock(mServiceLock);
1825
Ruben Brunkcc776712015-02-17 20:18:47 -08001826 {
1827 Mutex::Autolock lock(mStatusListenerLock);
1828 for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) {
Emilian Peev53722fa2019-02-22 17:47:20 -08001829 if (IInterface::asBinder(it->second->getListener()) == IInterface::asBinder(listener)) {
1830 mUidPolicy->unregisterMonitorUid(it->second->getListenerUid());
1831 IInterface::asBinder(listener)->unlinkToDeath(it->second);
Ruben Brunkcc776712015-02-17 20:18:47 -08001832 mListenerList.erase(it);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001833 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001834 }
Igor Murashkinbfc99152013-02-27 12:55:20 -08001835 }
1836 }
1837
1838 ALOGW("%s: Tried to remove a listener %p which was not subscribed",
1839 __FUNCTION__, listener.get());
1840
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001841 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Unregistered listener given to removeListener");
Igor Murashkin634a5152013-02-20 17:15:11 -08001842}
1843
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001844Status CameraService::getLegacyParameters(int cameraId, /*out*/String16* parameters) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001845
1846 ATRACE_CALL();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001847 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1848
1849 if (parameters == NULL) {
1850 ALOGE("%s: parameters must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001851 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
Igor Murashkin65d14b92014-06-17 12:03:20 -07001852 }
1853
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001854 Status ret = Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001855
1856 CameraParameters shimParams;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001857 if (!(ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)).isOk()) {
Igor Murashkin65d14b92014-06-17 12:03:20 -07001858 // Error logged by caller
1859 return ret;
1860 }
1861
1862 String8 shimParamsString8 = shimParams.flatten();
1863 String16 shimParamsString16 = String16(shimParamsString8);
1864
1865 *parameters = shimParamsString16;
1866
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001867 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -07001868}
1869
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001870Status CameraService::supportsCameraApi(const String16& cameraId, int apiVersion,
1871 /*out*/ bool *isSupported) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001872 ATRACE_CALL();
1873
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001874 const String8 id = String8(cameraId);
1875
1876 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001877
1878 switch (apiVersion) {
1879 case API_VERSION_1:
1880 case API_VERSION_2:
1881 break;
1882 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001883 String8 msg = String8::format("Unknown API version %d", apiVersion);
1884 ALOGE("%s: %s", __FUNCTION__, msg.string());
1885 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001886 }
1887
Emilian Peev28ad2ea2017-02-07 16:14:32 +00001888 int deviceVersion = getDeviceVersion(id);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001889 switch (deviceVersion) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001890 case CAMERA_DEVICE_API_VERSION_1_0:
1891 case CAMERA_DEVICE_API_VERSION_3_0:
1892 case CAMERA_DEVICE_API_VERSION_3_1:
1893 if (apiVersion == API_VERSION_2) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001894 ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim",
1895 __FUNCTION__, id.string(), deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001896 *isSupported = false;
1897 } else { // if (apiVersion == API_VERSION_1) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001898 ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported",
1899 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001900 *isSupported = true;
1901 }
1902 break;
1903 case CAMERA_DEVICE_API_VERSION_3_2:
1904 case CAMERA_DEVICE_API_VERSION_3_3:
Zhijun He4afbdec2016-05-04 15:42:51 -07001905 case CAMERA_DEVICE_API_VERSION_3_4:
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001906 case CAMERA_DEVICE_API_VERSION_3_5:
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001907 ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
1908 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001909 *isSupported = true;
1910 break;
1911 case -1: {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001912 String8 msg = String8::format("Unknown camera ID %s", id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001913 ALOGE("%s: %s", __FUNCTION__, msg.string());
1914 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001915 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001916 default: {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001917 String8 msg = String8::format("Unknown device version %x for device %s",
1918 deviceVersion, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001919 ALOGE("%s: %s", __FUNCTION__, msg.string());
1920 return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
1921 }
Igor Murashkin65d14b92014-06-17 12:03:20 -07001922 }
1923
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001924 return Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001925}
1926
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001927Status CameraService::isHiddenPhysicalCamera(const String16& cameraId,
1928 /*out*/ bool *isSupported) {
1929 ATRACE_CALL();
1930
1931 const String8 id = String8(cameraId);
1932
1933 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
1934 *isSupported = mCameraProviderManager->isHiddenPhysicalCamera(id.string());
1935
1936 return Status::ok();
1937}
1938
Ruben Brunkcc776712015-02-17 20:18:47 -08001939void CameraService::removeByClient(const BasicClient* client) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001940 Mutex::Autolock lock(mServiceLock);
Ruben Brunkcc776712015-02-17 20:18:47 -08001941 for (auto& i : mActiveClientManager.getAll()) {
1942 auto clientSp = i->getValue();
1943 if (clientSp.get() == client) {
1944 mActiveClientManager.remove(i);
Igor Murashkin634a5152013-02-20 17:15:11 -08001945 }
Igor Murashkinecf17e82012-10-02 16:05:11 -07001946 }
Igor Murashkin634a5152013-02-20 17:15:11 -08001947}
1948
Ruben Brunkcc776712015-02-17 20:18:47 -08001949bool CameraService::evictClientIdByRemote(const wp<IBinder>& remote) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001950 bool ret = false;
1951 {
1952 // Acquire mServiceLock and prevent other clients from connecting
1953 std::unique_ptr<AutoConditionLock> lock =
1954 AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
Igor Murashkin634a5152013-02-20 17:15:11 -08001955
Igor Murashkin634a5152013-02-20 17:15:11 -08001956
Ruben Brunkcc776712015-02-17 20:18:47 -08001957 std::vector<sp<BasicClient>> evicted;
1958 for (auto& i : mActiveClientManager.getAll()) {
1959 auto clientSp = i->getValue();
1960 if (clientSp.get() == nullptr) {
1961 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
1962 mActiveClientManager.remove(i);
1963 continue;
1964 }
Yin-Chia Yehdbfcb382018-02-16 11:17:36 -08001965 if (remote == clientSp->getRemote()) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001966 mActiveClientManager.remove(i);
1967 evicted.push_back(clientSp);
Igor Murashkin634a5152013-02-20 17:15:11 -08001968
Ruben Brunkcc776712015-02-17 20:18:47 -08001969 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001970 clientSp->notifyError(
1971 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -08001972 CaptureResultExtras());
Igor Murashkin634a5152013-02-20 17:15:11 -08001973 }
1974 }
1975
Ruben Brunkcc776712015-02-17 20:18:47 -08001976 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1977 // other clients from connecting in mServiceLockWrapper if held
1978 mServiceLock.unlock();
1979
Ruben Brunk36597b22015-03-20 22:15:57 -07001980 // Do not clear caller identity, remote caller should be client proccess
1981
Ruben Brunkcc776712015-02-17 20:18:47 -08001982 for (auto& i : evicted) {
1983 if (i.get() != nullptr) {
1984 i->disconnect();
1985 ret = true;
1986 }
Igor Murashkin634a5152013-02-20 17:15:11 -08001987 }
1988
Ruben Brunkcc776712015-02-17 20:18:47 -08001989 // Reacquire mServiceLock
1990 mServiceLock.lock();
Igor Murashkin634a5152013-02-20 17:15:11 -08001991
Ruben Brunkcc776712015-02-17 20:18:47 -08001992 } // lock is destroyed, allow further connect calls
1993
1994 return ret;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001995}
1996
Ruben Brunkcc776712015-02-17 20:18:47 -08001997std::shared_ptr<CameraService::CameraState> CameraService::getCameraState(
1998 const String8& cameraId) const {
1999 std::shared_ptr<CameraState> state;
2000 {
2001 Mutex::Autolock lock(mCameraStatesLock);
2002 auto iter = mCameraStates.find(cameraId);
2003 if (iter != mCameraStates.end()) {
2004 state = iter->second;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002005 }
2006 }
Ruben Brunkcc776712015-02-17 20:18:47 -08002007 return state;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002008}
2009
Ruben Brunkcc776712015-02-17 20:18:47 -08002010sp<CameraService::BasicClient> CameraService::removeClientLocked(const String8& cameraId) {
2011 // Remove from active clients list
2012 auto clientDescriptorPtr = mActiveClientManager.remove(cameraId);
2013 if (clientDescriptorPtr == nullptr) {
2014 ALOGW("%s: Could not evict client, no client for camera ID %s", __FUNCTION__,
2015 cameraId.string());
2016 return sp<BasicClient>{nullptr};
2017 }
2018
2019 return clientDescriptorPtr->getValue();
Keun young Parkd8973a72012-03-28 14:13:09 -07002020}
2021
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002022void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) {
Ruben Brunk36597b22015-03-20 22:15:57 -07002023 // Acquire mServiceLock and prevent other clients from connecting
2024 std::unique_ptr<AutoConditionLock> lock =
2025 AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
2026
Ruben Brunk6267b532015-04-30 17:44:07 -07002027 std::set<userid_t> newAllowedUsers;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002028 for (size_t i = 0; i < newUserIds.size(); i++) {
2029 if (newUserIds[i] < 0) {
Ruben Brunk6267b532015-04-30 17:44:07 -07002030 ALOGE("%s: Bad user ID %d given during user switch, ignoring.",
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002031 __FUNCTION__, newUserIds[i]);
Ruben Brunk6267b532015-04-30 17:44:07 -07002032 return;
2033 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002034 newAllowedUsers.insert(static_cast<userid_t>(newUserIds[i]));
Ruben Brunk36597b22015-03-20 22:15:57 -07002035 }
2036
Ruben Brunka8ca9152015-04-07 14:23:40 -07002037
Ruben Brunk6267b532015-04-30 17:44:07 -07002038 if (newAllowedUsers == mAllowedUsers) {
2039 ALOGW("%s: Received notification of user switch with no updated user IDs.", __FUNCTION__);
2040 return;
2041 }
2042
2043 logUserSwitch(mAllowedUsers, newAllowedUsers);
2044
2045 mAllowedUsers = std::move(newAllowedUsers);
Ruben Brunk36597b22015-03-20 22:15:57 -07002046
2047 // Current user has switched, evict all current clients.
2048 std::vector<sp<BasicClient>> evicted;
2049 for (auto& i : mActiveClientManager.getAll()) {
2050 auto clientSp = i->getValue();
2051
2052 if (clientSp.get() == nullptr) {
2053 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
2054 continue;
2055 }
2056
Ruben Brunk6267b532015-04-30 17:44:07 -07002057 // Don't evict clients that are still allowed.
2058 uid_t clientUid = clientSp->getClientUid();
2059 userid_t clientUserId = multiuser_get_user_id(clientUid);
2060 if (mAllowedUsers.find(clientUserId) != mAllowedUsers.end()) {
2061 continue;
2062 }
2063
Ruben Brunk36597b22015-03-20 22:15:57 -07002064 evicted.push_back(clientSp);
2065
2066 String8 curTime = getFormattedCurrentTime();
2067
2068 ALOGE("Evicting conflicting client for camera ID %s due to user change",
2069 i->getKey().string());
Ruben Brunka8ca9152015-04-07 14:23:40 -07002070
Ruben Brunk36597b22015-03-20 22:15:57 -07002071 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07002072 logEvent(String8::format("EVICT device %s client held by package %s (PID %"
Emilian Peev8131a262017-02-01 12:33:43 +00002073 PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted due"
2074 " to user switch.", i->getKey().string(),
2075 String8{clientSp->getPackageName()}.string(),
2076 i->getOwnerId(), i->getPriority().getScore(),
2077 i->getPriority().getState()));
Ruben Brunk36597b22015-03-20 22:15:57 -07002078
2079 }
2080
2081 // Do not hold mServiceLock while disconnecting clients, but retain the condition
2082 // blocking other clients from connecting in mServiceLockWrapper if held.
2083 mServiceLock.unlock();
2084
2085 // Clear caller identity temporarily so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -07002086 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunk36597b22015-03-20 22:15:57 -07002087
2088 for (auto& i : evicted) {
2089 i->disconnect();
2090 }
2091
Jayant Chowdhary12361932018-08-27 14:46:13 -07002092 CameraThreadState::restoreCallingIdentity(token);
Ruben Brunk36597b22015-03-20 22:15:57 -07002093
2094 // Reacquire mServiceLock
2095 mServiceLock.lock();
2096}
Ruben Brunkcc776712015-02-17 20:18:47 -08002097
Ruben Brunka8ca9152015-04-07 14:23:40 -07002098void CameraService::logEvent(const char* event) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002099 String8 curTime = getFormattedCurrentTime();
Ruben Brunka8ca9152015-04-07 14:23:40 -07002100 Mutex::Autolock l(mLogLock);
2101 mEventLog.add(String8::format("%s : %s", curTime.string(), event));
Mathias Agopian65ab4712010-07-14 17:59:35 -07002102}
2103
Ruben Brunka8ca9152015-04-07 14:23:40 -07002104void CameraService::logDisconnected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002105 const char* clientPackage) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002106 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07002107 logEvent(String8::format("DISCONNECT device %s client for package %s (PID %d)", cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002108 clientPackage, clientPid));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002109}
2110
2111void CameraService::logConnected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002112 const char* clientPackage) {
Ruben Brunka8ca9152015-04-07 14:23:40 -07002113 // Log the clients evicted
2114 logEvent(String8::format("CONNECT device %s client for package %s (PID %d)", cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002115 clientPackage, clientPid));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002116}
2117
2118void CameraService::logRejected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002119 const char* clientPackage, const char* reason) {
Ruben Brunka8ca9152015-04-07 14:23:40 -07002120 // Log the client rejected
2121 logEvent(String8::format("REJECT device %s client for package %s (PID %d), reason: (%s)",
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002122 cameraId, clientPackage, clientPid, reason));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002123}
2124
Ruben Brunk6267b532015-04-30 17:44:07 -07002125void CameraService::logUserSwitch(const std::set<userid_t>& oldUserIds,
2126 const std::set<userid_t>& newUserIds) {
2127 String8 newUsers = toString(newUserIds);
2128 String8 oldUsers = toString(oldUserIds);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002129 if (oldUsers.size() == 0) {
2130 oldUsers = "<None>";
2131 }
Ruben Brunka8ca9152015-04-07 14:23:40 -07002132 // Log the new and old users
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002133 logEvent(String8::format("USER_SWITCH previous allowed user IDs: %s, current allowed user IDs: %s",
Ruben Brunk6267b532015-04-30 17:44:07 -07002134 oldUsers.string(), newUsers.string()));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002135}
2136
2137void CameraService::logDeviceRemoved(const char* cameraId, const char* reason) {
2138 // Log the device removal
2139 logEvent(String8::format("REMOVE device %s, reason: (%s)", cameraId, reason));
2140}
2141
2142void CameraService::logDeviceAdded(const char* cameraId, const char* reason) {
2143 // Log the device removal
2144 logEvent(String8::format("ADD device %s, reason: (%s)", cameraId, reason));
2145}
2146
2147void CameraService::logClientDied(int clientPid, const char* reason) {
2148 // Log the device removal
2149 logEvent(String8::format("DIED client(s) with PID %d, reason: (%s)", clientPid, reason));
Igor Murashkinecf17e82012-10-02 16:05:11 -07002150}
2151
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002152void CameraService::logServiceError(const char* msg, int errorCode) {
2153 String8 curTime = getFormattedCurrentTime();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08002154 logEvent(String8::format("SERVICE ERROR: %s : %d (%s)", msg, errorCode, strerror(-errorCode)));
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002155}
2156
Ruben Brunk36597b22015-03-20 22:15:57 -07002157status_t CameraService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
2158 uint32_t flags) {
2159
Mathias Agopian65ab4712010-07-14 17:59:35 -07002160 // Permission checks
2161 switch (code) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002162 case SHELL_COMMAND_TRANSACTION: {
2163 int in = data.readFileDescriptor();
2164 int out = data.readFileDescriptor();
2165 int err = data.readFileDescriptor();
2166 int argc = data.readInt32();
2167 Vector<String16> args;
2168 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
2169 args.add(data.readString16());
2170 }
2171 sp<IBinder> unusedCallback;
2172 sp<IResultReceiver> resultReceiver;
2173 status_t status;
2174 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
2175 return status;
2176 }
2177 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
2178 return status;
2179 }
2180 status = shellCommand(in, out, err, args);
2181 if (resultReceiver != nullptr) {
2182 resultReceiver->send(status);
2183 }
2184 return NO_ERROR;
2185 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002186 }
2187
2188 return BnCameraService::onTransact(code, data, reply, flags);
2189}
2190
Mathias Agopian65ab4712010-07-14 17:59:35 -07002191// We share the media players for shutter and recording sound for all clients.
2192// A reference count is kept to determine when we will actually release the
2193// media players.
2194
Jaekyun Seokef498052018-03-23 13:09:44 +09002195sp<MediaPlayer> CameraService::newMediaPlayer(const char *file) {
2196 sp<MediaPlayer> mp = new MediaPlayer();
2197 status_t error;
2198 if ((error = mp->setDataSource(NULL /* httpService */, file, NULL)) == NO_ERROR) {
Eino-Ville Talvala60a78ac2012-01-05 15:34:53 -08002199 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
Jaekyun Seokef498052018-03-23 13:09:44 +09002200 error = mp->prepare();
2201 }
2202 if (error != NO_ERROR) {
Steve Block29357bc2012-01-06 19:20:56 +00002203 ALOGE("Failed to load CameraService sounds: %s", file);
Jaekyun Seokef498052018-03-23 13:09:44 +09002204 mp->disconnect();
2205 mp.clear();
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002206 return nullptr;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002207 }
2208 return mp;
2209}
2210
username5755fea2018-12-27 09:48:08 +08002211void CameraService::increaseSoundRef() {
2212 Mutex::Autolock lock(mSoundLock);
2213 mSoundRef++;
2214}
2215
2216void CameraService::loadSoundLocked(sound_kind kind) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002217 ATRACE_CALL();
2218
username5755fea2018-12-27 09:48:08 +08002219 LOG1("CameraService::loadSoundLocked ref=%d", mSoundRef);
2220 if (SOUND_SHUTTER == kind && mSoundPlayer[SOUND_SHUTTER] == NULL) {
2221 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/product/media/audio/ui/camera_click.ogg");
2222 if (mSoundPlayer[SOUND_SHUTTER] == nullptr) {
2223 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
2224 }
2225 } else if (SOUND_RECORDING_START == kind && mSoundPlayer[SOUND_RECORDING_START] == NULL) {
2226 mSoundPlayer[SOUND_RECORDING_START] = newMediaPlayer("/product/media/audio/ui/VideoRecord.ogg");
2227 if (mSoundPlayer[SOUND_RECORDING_START] == nullptr) {
2228 mSoundPlayer[SOUND_RECORDING_START] =
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002229 newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
username5755fea2018-12-27 09:48:08 +08002230 }
2231 } else if (SOUND_RECORDING_STOP == kind && mSoundPlayer[SOUND_RECORDING_STOP] == NULL) {
2232 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/product/media/audio/ui/VideoStop.ogg");
2233 if (mSoundPlayer[SOUND_RECORDING_STOP] == nullptr) {
2234 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/system/media/audio/ui/VideoStop.ogg");
2235 }
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002236 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002237}
2238
username5755fea2018-12-27 09:48:08 +08002239void CameraService::decreaseSoundRef() {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002240 Mutex::Autolock lock(mSoundLock);
username5755fea2018-12-27 09:48:08 +08002241 LOG1("CameraService::decreaseSoundRef ref=%d", mSoundRef);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002242 if (--mSoundRef) return;
2243
2244 for (int i = 0; i < NUM_SOUNDS; i++) {
2245 if (mSoundPlayer[i] != 0) {
2246 mSoundPlayer[i]->disconnect();
2247 mSoundPlayer[i].clear();
2248 }
2249 }
2250}
2251
2252void CameraService::playSound(sound_kind kind) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002253 ATRACE_CALL();
2254
Mathias Agopian65ab4712010-07-14 17:59:35 -07002255 LOG1("playSound(%d)", kind);
2256 Mutex::Autolock lock(mSoundLock);
username5755fea2018-12-27 09:48:08 +08002257 loadSoundLocked(kind);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002258 sp<MediaPlayer> player = mSoundPlayer[kind];
2259 if (player != 0) {
Chih-Chung Chang8888a752011-10-20 10:47:26 +08002260 player->seekTo(0);
2261 player->start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002262 }
2263}
2264
2265// ----------------------------------------------------------------------------
2266
2267CameraService::Client::Client(const sp<CameraService>& cameraService,
Wu-cheng Lib7a67942010-08-17 15:45:37 -07002268 const sp<ICameraClient>& cameraClient,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002269 const String16& clientPackageName,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002270 const String8& cameraIdStr,
2271 int api1CameraId, int cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002272 int clientPid, uid_t clientUid,
2273 int servicePid) :
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08002274 CameraService::BasicClient(cameraService,
Marco Nelissenf8880202014-11-14 07:58:25 -08002275 IInterface::asBinder(cameraClient),
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002276 clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002277 cameraIdStr, cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002278 clientPid, clientUid,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002279 servicePid),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002280 mCameraId(api1CameraId)
Igor Murashkin634a5152013-02-20 17:15:11 -08002281{
Jayant Chowdhary12361932018-08-27 14:46:13 -07002282 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002283 LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002284
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002285 mRemoteCallback = cameraClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002286
username5755fea2018-12-27 09:48:08 +08002287 cameraService->increaseSoundRef();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002288
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002289 LOG1("Client::Client X (pid %d, id %d)", callingPid, mCameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002290}
2291
Mathias Agopian65ab4712010-07-14 17:59:35 -07002292// tear down the client
2293CameraService::Client::~Client() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002294 ALOGV("~Client");
Igor Murashkin634a5152013-02-20 17:15:11 -08002295 mDestructionStarted = true;
2296
username5755fea2018-12-27 09:48:08 +08002297 sCameraService->decreaseSoundRef();
Igor Murashkin036bc3e2012-10-08 15:09:46 -07002298 // unconditionally disconnect. function is idempotent
2299 Client::disconnect();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002300}
2301
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002302sp<CameraService> CameraService::BasicClient::BasicClient::sCameraService;
2303
Igor Murashkin634a5152013-02-20 17:15:11 -08002304CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002305 const sp<IBinder>& remoteCallback,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002306 const String16& clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002307 const String8& cameraIdStr, int cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002308 int clientPid, uid_t clientUid,
2309 int servicePid):
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002310 mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing),
2311 mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid),
2312 mServicePid(servicePid),
2313 mDisconnected(false),
2314 mRemoteBinder(remoteCallback)
Igor Murashkin634a5152013-02-20 17:15:11 -08002315{
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002316 if (sCameraService == nullptr) {
2317 sCameraService = cameraService;
2318 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002319 mOpsActive = false;
Igor Murashkin634a5152013-02-20 17:15:11 -08002320 mDestructionStarted = false;
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -08002321
2322 // In some cases the calling code has no access to the package it runs under.
2323 // For example, NDK camera API.
2324 // In this case we will get the packages for the calling UID and pick the first one
2325 // for attributing the app op. This will work correctly for runtime permissions
2326 // as for legacy apps we will toggle the app op for all packages in the UID.
2327 // The caveat is that the operation may be attributed to the wrong package and
2328 // stats based on app ops may be slightly off.
2329 if (mClientPackageName.size() <= 0) {
2330 sp<IServiceManager> sm = defaultServiceManager();
2331 sp<IBinder> binder = sm->getService(String16(kPermissionServiceName));
2332 if (binder == 0) {
2333 ALOGE("Cannot get permission service");
2334 // Leave mClientPackageName unchanged (empty) and the further interaction
2335 // with camera will fail in BasicClient::startCameraOps
2336 return;
2337 }
2338
2339 sp<IPermissionController> permCtrl = interface_cast<IPermissionController>(binder);
2340 Vector<String16> packages;
2341
2342 permCtrl->getPackagesForUid(mClientUid, packages);
2343
2344 if (packages.isEmpty()) {
2345 ALOGE("No packages for calling UID");
2346 // Leave mClientPackageName unchanged (empty) and the further interaction
2347 // with camera will fail in BasicClient::startCameraOps
2348 return;
2349 }
2350 mClientPackageName = packages[0];
2351 }
Igor Murashkin634a5152013-02-20 17:15:11 -08002352}
2353
2354CameraService::BasicClient::~BasicClient() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002355 ALOGV("~BasicClient");
Igor Murashkin634a5152013-02-20 17:15:11 -08002356 mDestructionStarted = true;
2357}
2358
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002359binder::Status CameraService::BasicClient::disconnect() {
2360 binder::Status res = Status::ok();
Ruben Brunk36597b22015-03-20 22:15:57 -07002361 if (mDisconnected) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002362 return res;
Ruben Brunk36597b22015-03-20 22:15:57 -07002363 }
Eino-Ville Talvala24901c82015-09-04 14:15:58 -07002364 mDisconnected = true;
Ruben Brunkcc776712015-02-17 20:18:47 -08002365
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002366 sCameraService->removeByClient(this);
2367 sCameraService->logDisconnected(mCameraIdStr, mClientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002368 String8(mClientPackageName));
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002369 sCameraService->mCameraProviderManager->removeRef(CameraProviderManager::DeviceMode::CAMERA,
2370 mCameraIdStr.c_str());
Ruben Brunkcc776712015-02-17 20:18:47 -08002371
2372 sp<IBinder> remote = getRemote();
2373 if (remote != nullptr) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002374 remote->unlinkToDeath(sCameraService);
Ruben Brunkcc776712015-02-17 20:18:47 -08002375 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002376
2377 finishCameraOps();
Chien-Yu Chene4fe21b2016-08-04 12:42:40 -07002378 // Notify flashlight that a camera device is closed.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002379 sCameraService->mFlashlight->deviceClosed(mCameraIdStr);
2380 ALOGI("%s: Disconnected client for camera %s for PID %d", __FUNCTION__, mCameraIdStr.string(),
2381 mClientPid);
Ruben Brunkcc776712015-02-17 20:18:47 -08002382
Igor Murashkincba2c162013-03-20 15:56:31 -07002383 // client shouldn't be able to call into us anymore
2384 mClientPid = 0;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002385
2386 return res;
Igor Murashkin634a5152013-02-20 17:15:11 -08002387}
2388
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08002389status_t CameraService::BasicClient::dump(int, const Vector<String16>&) {
2390 // No dumping of clients directly over Binder,
2391 // must go through CameraService::dump
2392 android_errorWriteWithInfoLog(SN_EVENT_LOG_ID, "26265403",
Jayant Chowdhary12361932018-08-27 14:46:13 -07002393 CameraThreadState::getCallingUid(), NULL, 0);
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08002394 return OK;
2395}
2396
Ruben Brunkcc776712015-02-17 20:18:47 -08002397String16 CameraService::BasicClient::getPackageName() const {
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002398 return mClientPackageName;
Ruben Brunkcc776712015-02-17 20:18:47 -08002399}
2400
2401
2402int CameraService::BasicClient::getClientPid() const {
2403 return mClientPid;
2404}
2405
Ruben Brunk6267b532015-04-30 17:44:07 -07002406uid_t CameraService::BasicClient::getClientUid() const {
2407 return mClientUid;
2408}
2409
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07002410bool CameraService::BasicClient::canCastToApiClient(apiLevel level) const {
2411 // Defaults to API2.
2412 return level == API_2;
2413}
2414
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002415status_t CameraService::BasicClient::startCameraOps() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002416 ATRACE_CALL();
2417
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002418 int32_t res;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002419 // Notify app ops that the camera is not available
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002420 mOpsCallback = new OpsCallback(this);
2421
Igor Murashkine6800ce2013-03-04 17:25:57 -08002422 {
2423 ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002424 __FUNCTION__, String8(mClientPackageName).string(), mClientUid);
Igor Murashkine6800ce2013-03-04 17:25:57 -08002425 }
2426
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002427 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002428 mClientPackageName, mOpsCallback);
Svet Ganov1d519102018-02-26 10:48:14 -08002429 res = mAppOpsManager.startOpNoThrow(AppOpsManager::OP_CAMERA,
2430 mClientUid, mClientPackageName, /*startIfModeDefault*/ false);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002431
Svetoslav28e8ef72015-05-11 19:21:31 -07002432 if (res == AppOpsManager::MODE_ERRORED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002433 ALOGI("Camera %s: Access for \"%s\" has been revoked",
2434 mCameraIdStr.string(), String8(mClientPackageName).string());
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002435 return PERMISSION_DENIED;
2436 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002437
Svetoslav28e8ef72015-05-11 19:21:31 -07002438 if (res == AppOpsManager::MODE_IGNORED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002439 ALOGI("Camera %s: Access for \"%s\" has been restricted",
2440 mCameraIdStr.string(), String8(mClientPackageName).string());
Eino-Ville Talvalae3afb2c2015-06-03 16:03:30 -07002441 // Return the same error as for device policy manager rejection
2442 return -EACCES;
Svetoslav28e8ef72015-05-11 19:21:31 -07002443 }
2444
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002445 mOpsActive = true;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002446
2447 // Transition device availability listeners from PRESENT -> NOT_AVAILABLE
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002448 sCameraService->updateStatus(StatusInternal::NOT_AVAILABLE, mCameraIdStr);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002449
Emilian Peev573291c2018-02-10 02:10:56 +00002450 int apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_1;
2451 if (canCastToApiClient(API_2)) {
2452 apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_2;
2453 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002454 // Transition device state to OPEN
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002455 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
Emilian Peev573291c2018-02-10 02:10:56 +00002456 mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002457
Emilian Peev53722fa2019-02-22 17:47:20 -08002458 sCameraService->mUidPolicy->registerMonitorUid(mClientUid);
2459
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002460 return OK;
2461}
2462
2463status_t CameraService::BasicClient::finishCameraOps() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002464 ATRACE_CALL();
2465
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002466 // Check if startCameraOps succeeded, and if so, finish the camera op
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002467 if (mOpsActive) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002468 // Notify app ops that the camera is available again
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002469 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002470 mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002471 mOpsActive = false;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002472
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002473 // This function is called when a client disconnects. This should
2474 // release the camera, but actually only if it was in a proper
2475 // functional state, i.e. with status NOT_AVAILABLE
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002476 std::initializer_list<StatusInternal> rejected = {StatusInternal::PRESENT,
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002477 StatusInternal::ENUMERATING, StatusInternal::NOT_PRESENT};
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002478
Ruben Brunkcc776712015-02-17 20:18:47 -08002479 // Transition to PRESENT if the camera is not in either of the rejected states
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002480 sCameraService->updateStatus(StatusInternal::PRESENT,
2481 mCameraIdStr, rejected);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002482
Emilian Peev573291c2018-02-10 02:10:56 +00002483 int apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_1;
2484 if (canCastToApiClient(API_2)) {
2485 apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_2;
2486 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002487 // Transition device state to CLOSED
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002488 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED,
Emilian Peev573291c2018-02-10 02:10:56 +00002489 mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002490 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002491 // Always stop watching, even if no camera op is active
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08002492 if (mOpsCallback != NULL) {
2493 mAppOpsManager.stopWatchingMode(mOpsCallback);
2494 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002495 mOpsCallback.clear();
2496
Emilian Peev53722fa2019-02-22 17:47:20 -08002497 sCameraService->mUidPolicy->unregisterMonitorUid(mClientUid);
2498
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002499 return OK;
2500}
2501
2502void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002503 ATRACE_CALL();
2504
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002505 String8 name(packageName);
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002506 String8 myName(mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002507
2508 if (op != AppOpsManager::OP_CAMERA) {
2509 ALOGW("Unexpected app ops notification received: %d", op);
2510 return;
2511 }
2512
2513 int32_t res;
2514 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002515 mClientUid, mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002516 ALOGV("checkOp returns: %d, %s ", res,
2517 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" :
2518 res == AppOpsManager::MODE_IGNORED ? "IGNORED" :
2519 res == AppOpsManager::MODE_ERRORED ? "ERRORED" :
2520 "UNKNOWN");
2521
2522 if (res != AppOpsManager::MODE_ALLOWED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002523 ALOGI("Camera %s: Access for \"%s\" revoked", mCameraIdStr.string(),
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002524 myName.string());
Svet Ganova453d0d2018-01-11 15:37:58 -08002525 block();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002526 }
2527}
2528
Svet Ganova453d0d2018-01-11 15:37:58 -08002529void CameraService::BasicClient::block() {
2530 ATRACE_CALL();
2531
2532 // Reset the client PID to allow server-initiated disconnect,
2533 // and to prevent further calls by client.
Jayant Chowdhary12361932018-08-27 14:46:13 -07002534 mClientPid = CameraThreadState::getCallingPid();
Svet Ganova453d0d2018-01-11 15:37:58 -08002535 CaptureResultExtras resultExtras; // a dummy result (invalid)
2536 notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED, resultExtras);
2537 disconnect();
2538}
2539
Mathias Agopian65ab4712010-07-14 17:59:35 -07002540// ----------------------------------------------------------------------------
2541
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002542void CameraService::Client::notifyError(int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -07002543 const CaptureResultExtras& resultExtras) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08002544 (void) resultExtras;
Ranjith Kagathi Ananda3e600892015-10-08 16:00:33 -07002545 if (mRemoteCallback != NULL) {
Yin-Chia Yehf13bda52018-05-31 12:12:59 -07002546 int32_t api1ErrorCode = CAMERA_ERROR_RELEASED;
2547 if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED) {
2548 api1ErrorCode = CAMERA_ERROR_DISABLED;
2549 }
2550 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, api1ErrorCode, 0);
Ranjith Kagathi Ananda3e600892015-10-08 16:00:33 -07002551 } else {
2552 ALOGE("mRemoteCallback is NULL!!");
2553 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002554}
2555
Igor Murashkin036bc3e2012-10-08 15:09:46 -07002556// NOTE: function is idempotent
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002557binder::Status CameraService::Client::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002558 ALOGV("Client::disconnect");
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002559 return BasicClient::disconnect();
Wu-cheng Lie09591e2010-10-14 20:17:44 +08002560}
2561
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07002562bool CameraService::Client::canCastToApiClient(apiLevel level) const {
2563 return level == API_1;
2564}
2565
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002566CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client):
2567 mClient(client) {
2568}
2569
2570void CameraService::Client::OpsCallback::opChanged(int32_t op,
2571 const String16& packageName) {
2572 sp<BasicClient> client = mClient.promote();
2573 if (client != NULL) {
2574 client->opChanged(op, packageName);
2575 }
2576}
2577
Mathias Agopian65ab4712010-07-14 17:59:35 -07002578// ----------------------------------------------------------------------------
Svet Ganova453d0d2018-01-11 15:37:58 -08002579// UidPolicy
2580// ----------------------------------------------------------------------------
2581
2582void CameraService::UidPolicy::registerSelf() {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002583 Mutex::Autolock _l(mUidLock);
2584
Svet Ganova453d0d2018-01-11 15:37:58 -08002585 ActivityManager am;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002586 if (mRegistered) return;
Svet Ganova453d0d2018-01-11 15:37:58 -08002587 am.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
2588 | ActivityManager::UID_OBSERVER_IDLE
Emilian Peev53722fa2019-02-22 17:47:20 -08002589 | ActivityManager::UID_OBSERVER_ACTIVE | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganova453d0d2018-01-11 15:37:58 -08002590 ActivityManager::PROCESS_STATE_UNKNOWN,
2591 String16("cameraserver"));
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002592 status_t res = am.linkToDeath(this);
2593 if (res == OK) {
2594 mRegistered = true;
2595 ALOGV("UidPolicy: Registered with ActivityManager");
2596 }
Svet Ganova453d0d2018-01-11 15:37:58 -08002597}
2598
2599void CameraService::UidPolicy::unregisterSelf() {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002600 Mutex::Autolock _l(mUidLock);
2601
Svet Ganova453d0d2018-01-11 15:37:58 -08002602 ActivityManager am;
2603 am.unregisterUidObserver(this);
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002604 am.unlinkToDeath(this);
2605 mRegistered = false;
2606 mActiveUids.clear();
2607 ALOGV("UidPolicy: Unregistered with ActivityManager");
Svet Ganova453d0d2018-01-11 15:37:58 -08002608}
2609
2610void CameraService::UidPolicy::onUidGone(uid_t uid, bool disabled) {
2611 onUidIdle(uid, disabled);
2612}
2613
2614void CameraService::UidPolicy::onUidActive(uid_t uid) {
2615 Mutex::Autolock _l(mUidLock);
2616 mActiveUids.insert(uid);
2617}
2618
2619void CameraService::UidPolicy::onUidIdle(uid_t uid, bool /* disabled */) {
2620 bool deleted = false;
2621 {
2622 Mutex::Autolock _l(mUidLock);
2623 if (mActiveUids.erase(uid) > 0) {
2624 deleted = true;
2625 }
2626 }
2627 if (deleted) {
2628 sp<CameraService> service = mService.promote();
2629 if (service != nullptr) {
2630 service->blockClientsForUid(uid);
2631 }
2632 }
2633}
2634
Emilian Peev53722fa2019-02-22 17:47:20 -08002635void CameraService::UidPolicy::onUidStateChanged(uid_t uid, int32_t procState,
2636 int64_t /*procStateSeq*/) {
2637 bool procStateChange = false;
2638 {
2639 Mutex::Autolock _l(mUidLock);
2640 if ((mMonitoredUids.find(uid) != mMonitoredUids.end()) &&
2641 (mMonitoredUids[uid].first != procState)) {
2642 mMonitoredUids[uid].first = procState;
2643 procStateChange = true;
2644 }
2645 }
2646
2647 if (procStateChange) {
2648 sp<CameraService> service = mService.promote();
2649 if (service != nullptr) {
2650 service->notifyMonitoredUids();
2651 }
2652 }
2653}
2654
2655void CameraService::UidPolicy::registerMonitorUid(uid_t uid) {
2656 Mutex::Autolock _l(mUidLock);
2657 auto it = mMonitoredUids.find(uid);
2658 if (it != mMonitoredUids.end()) {
2659 it->second.second++;
2660 } else {
2661 mMonitoredUids.emplace(
2662 std::pair<uid_t, std::pair<int32_t, size_t>> (uid,
2663 std::pair<int32_t, size_t> (ActivityManager::PROCESS_STATE_NONEXISTENT, 1)));
2664 }
2665}
2666
2667void CameraService::UidPolicy::unregisterMonitorUid(uid_t uid) {
2668 Mutex::Autolock _l(mUidLock);
2669 auto it = mMonitoredUids.find(uid);
2670 if (it != mMonitoredUids.end()) {
2671 it->second.second--;
2672 if (it->second.second == 0) {
2673 mMonitoredUids.erase(it);
2674 }
2675 } else {
2676 ALOGE("%s: Trying to unregister uid: %d which is not monitored!", __FUNCTION__, uid);
2677 }
2678}
2679
Svet Ganov7b4ab782018-03-25 12:48:10 -07002680bool CameraService::UidPolicy::isUidActive(uid_t uid, String16 callingPackage) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002681 Mutex::Autolock _l(mUidLock);
Svet Ganov7b4ab782018-03-25 12:48:10 -07002682 return isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002683}
2684
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002685static const int64_t kPollUidActiveTimeoutTotalMillis = 300;
2686static const int64_t kPollUidActiveTimeoutMillis = 50;
Svet Ganov94ec46f2018-06-08 15:03:46 -07002687
Svet Ganov7b4ab782018-03-25 12:48:10 -07002688bool CameraService::UidPolicy::isUidActiveLocked(uid_t uid, String16 callingPackage) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002689 // Non-app UIDs are considered always active
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002690 // If activity manager is unreachable, assume everything is active
2691 if (uid < FIRST_APPLICATION_UID || !mRegistered) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002692 return true;
2693 }
2694 auto it = mOverrideUids.find(uid);
2695 if (it != mOverrideUids.end()) {
2696 return it->second;
2697 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07002698 bool active = mActiveUids.find(uid) != mActiveUids.end();
2699 if (!active) {
2700 // We want active UIDs to always access camera with their first attempt since
2701 // there is no guarantee the app is robustly written and would retry getting
2702 // the camera on failure. The inverse case is not a problem as we would take
2703 // camera away soon once we get the callback that the uid is no longer active.
2704 ActivityManager am;
2705 // Okay to access with a lock held as UID changes are dispatched without
2706 // a lock and we are a higher level component.
Svet Ganov94ec46f2018-06-08 15:03:46 -07002707 int64_t startTimeMillis = 0;
2708 do {
2709 // TODO: Fix this b/109950150!
2710 // Okay this is a hack. There is a race between the UID turning active and
2711 // activity being resumed. The proper fix is very risky, so we temporary add
2712 // some polling which should happen pretty rarely anyway as the race is hard
2713 // to hit.
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002714 active = mActiveUids.find(uid) != mActiveUids.end();
2715 if (!active) active = am.isUidActive(uid, callingPackage);
Svet Ganov94ec46f2018-06-08 15:03:46 -07002716 if (active) {
2717 break;
2718 }
2719 if (startTimeMillis <= 0) {
2720 startTimeMillis = uptimeMillis();
2721 }
2722 int64_t ellapsedTimeMillis = uptimeMillis() - startTimeMillis;
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002723 int64_t remainingTimeMillis = kPollUidActiveTimeoutTotalMillis - ellapsedTimeMillis;
Svet Ganov94ec46f2018-06-08 15:03:46 -07002724 if (remainingTimeMillis <= 0) {
2725 break;
2726 }
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002727 remainingTimeMillis = std::min(kPollUidActiveTimeoutMillis, remainingTimeMillis);
2728
2729 mUidLock.unlock();
Svet Ganov94ec46f2018-06-08 15:03:46 -07002730 usleep(remainingTimeMillis * 1000);
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002731 mUidLock.lock();
Svet Ganov94ec46f2018-06-08 15:03:46 -07002732 } while (true);
2733
Svet Ganov7b4ab782018-03-25 12:48:10 -07002734 if (active) {
2735 // Now that we found out the UID is actually active, cache that
2736 mActiveUids.insert(uid);
2737 }
2738 }
2739 return active;
Svet Ganova453d0d2018-01-11 15:37:58 -08002740}
2741
Varun Shahb42f1eb2019-04-16 14:45:13 -07002742int32_t CameraService::UidPolicy::getProcState(uid_t uid) {
2743 Mutex::Autolock _l(mUidLock);
2744 return getProcStateLocked(uid);
2745}
2746
2747int32_t CameraService::UidPolicy::getProcStateLocked(uid_t uid) {
2748 int32_t procState = ActivityManager::PROCESS_STATE_UNKNOWN;
2749 if (mMonitoredUids.find(uid) != mMonitoredUids.end()) {
2750 procState = mMonitoredUids[uid].first;
2751 }
2752 return procState;
2753}
2754
Svet Ganov7b4ab782018-03-25 12:48:10 -07002755void CameraService::UidPolicy::UidPolicy::addOverrideUid(uid_t uid,
2756 String16 callingPackage, bool active) {
2757 updateOverrideUid(uid, callingPackage, active, true);
Svet Ganova453d0d2018-01-11 15:37:58 -08002758}
2759
Svet Ganov7b4ab782018-03-25 12:48:10 -07002760void CameraService::UidPolicy::removeOverrideUid(uid_t uid, String16 callingPackage) {
2761 updateOverrideUid(uid, callingPackage, false, false);
Svet Ganova453d0d2018-01-11 15:37:58 -08002762}
2763
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002764void CameraService::UidPolicy::binderDied(const wp<IBinder>& /*who*/) {
2765 Mutex::Autolock _l(mUidLock);
2766 ALOGV("UidPolicy: ActivityManager has died");
2767 mRegistered = false;
2768 mActiveUids.clear();
2769}
2770
Svet Ganov7b4ab782018-03-25 12:48:10 -07002771void CameraService::UidPolicy::updateOverrideUid(uid_t uid, String16 callingPackage,
2772 bool active, bool insert) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002773 bool wasActive = false;
2774 bool isActive = false;
2775 {
2776 Mutex::Autolock _l(mUidLock);
Svet Ganov7b4ab782018-03-25 12:48:10 -07002777 wasActive = isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002778 mOverrideUids.erase(uid);
2779 if (insert) {
2780 mOverrideUids.insert(std::pair<uid_t, bool>(uid, active));
2781 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07002782 isActive = isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002783 }
2784 if (wasActive != isActive && !isActive) {
2785 sp<CameraService> service = mService.promote();
2786 if (service != nullptr) {
2787 service->blockClientsForUid(uid);
2788 }
2789 }
2790}
2791
2792// ----------------------------------------------------------------------------
Michael Grooverd1d435a2018-12-18 17:39:42 -08002793// SensorPrivacyPolicy
2794// ----------------------------------------------------------------------------
2795void CameraService::SensorPrivacyPolicy::registerSelf() {
2796 Mutex::Autolock _l(mSensorPrivacyLock);
2797 if (mRegistered) {
2798 return;
2799 }
2800 SensorPrivacyManager spm;
2801 spm.addSensorPrivacyListener(this);
2802 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
2803 status_t res = spm.linkToDeath(this);
2804 if (res == OK) {
2805 mRegistered = true;
2806 ALOGV("SensorPrivacyPolicy: Registered with SensorPrivacyManager");
2807 }
2808}
2809
2810void CameraService::SensorPrivacyPolicy::unregisterSelf() {
2811 Mutex::Autolock _l(mSensorPrivacyLock);
2812 SensorPrivacyManager spm;
2813 spm.removeSensorPrivacyListener(this);
2814 spm.unlinkToDeath(this);
2815 mRegistered = false;
2816 ALOGV("SensorPrivacyPolicy: Unregistered with SensorPrivacyManager");
2817}
2818
2819bool CameraService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
2820 Mutex::Autolock _l(mSensorPrivacyLock);
2821 return mSensorPrivacyEnabled;
2822}
2823
2824binder::Status CameraService::SensorPrivacyPolicy::onSensorPrivacyChanged(bool enabled) {
2825 {
2826 Mutex::Autolock _l(mSensorPrivacyLock);
2827 mSensorPrivacyEnabled = enabled;
2828 }
2829 // if sensor privacy is enabled then block all clients from accessing the camera
2830 if (enabled) {
2831 sp<CameraService> service = mService.promote();
2832 if (service != nullptr) {
2833 service->blockAllClients();
2834 }
2835 }
2836 return binder::Status::ok();
2837}
2838
2839void CameraService::SensorPrivacyPolicy::binderDied(const wp<IBinder>& /*who*/) {
2840 Mutex::Autolock _l(mSensorPrivacyLock);
2841 ALOGV("SensorPrivacyPolicy: SensorPrivacyManager has died");
2842 mRegistered = false;
2843}
2844
2845// ----------------------------------------------------------------------------
Ruben Brunkcc776712015-02-17 20:18:47 -08002846// CameraState
2847// ----------------------------------------------------------------------------
2848
2849CameraService::CameraState::CameraState(const String8& id, int cost,
2850 const std::set<String8>& conflicting) : mId(id),
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002851 mStatus(StatusInternal::NOT_PRESENT), mCost(cost), mConflicting(conflicting) {}
Ruben Brunkcc776712015-02-17 20:18:47 -08002852
2853CameraService::CameraState::~CameraState() {}
2854
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002855CameraService::StatusInternal CameraService::CameraState::getStatus() const {
Ruben Brunkcc776712015-02-17 20:18:47 -08002856 Mutex::Autolock lock(mStatusLock);
2857 return mStatus;
2858}
2859
2860CameraParameters CameraService::CameraState::getShimParams() const {
2861 return mShimParams;
2862}
2863
2864void CameraService::CameraState::setShimParams(const CameraParameters& params) {
2865 mShimParams = params;
2866}
2867
2868int CameraService::CameraState::getCost() const {
2869 return mCost;
2870}
2871
2872std::set<String8> CameraService::CameraState::getConflicting() const {
2873 return mConflicting;
2874}
2875
2876String8 CameraService::CameraState::getId() const {
2877 return mId;
2878}
2879
2880// ----------------------------------------------------------------------------
Ruben Brunk99e69712015-05-26 17:25:07 -07002881// ClientEventListener
2882// ----------------------------------------------------------------------------
2883
2884void CameraService::ClientEventListener::onClientAdded(
2885 const resource_policy::ClientDescriptor<String8,
2886 sp<CameraService::BasicClient>>& descriptor) {
Chih-Hung Hsieh5404ee12016-08-09 14:25:53 -07002887 const auto& basicClient = descriptor.getValue();
Ruben Brunk99e69712015-05-26 17:25:07 -07002888 if (basicClient.get() != nullptr) {
2889 BatteryNotifier& notifier(BatteryNotifier::getInstance());
2890 notifier.noteStartCamera(descriptor.getKey(),
2891 static_cast<int>(basicClient->getClientUid()));
2892 }
2893}
2894
2895void CameraService::ClientEventListener::onClientRemoved(
2896 const resource_policy::ClientDescriptor<String8,
2897 sp<CameraService::BasicClient>>& descriptor) {
Chih-Hung Hsieh5404ee12016-08-09 14:25:53 -07002898 const auto& basicClient = descriptor.getValue();
Ruben Brunk99e69712015-05-26 17:25:07 -07002899 if (basicClient.get() != nullptr) {
2900 BatteryNotifier& notifier(BatteryNotifier::getInstance());
2901 notifier.noteStopCamera(descriptor.getKey(),
2902 static_cast<int>(basicClient->getClientUid()));
2903 }
2904}
2905
2906
2907// ----------------------------------------------------------------------------
Ruben Brunkcc776712015-02-17 20:18:47 -08002908// CameraClientManager
2909// ----------------------------------------------------------------------------
2910
Ruben Brunk99e69712015-05-26 17:25:07 -07002911CameraService::CameraClientManager::CameraClientManager() {
2912 setListener(std::make_shared<ClientEventListener>());
2913}
2914
Ruben Brunkcc776712015-02-17 20:18:47 -08002915CameraService::CameraClientManager::~CameraClientManager() {}
2916
2917sp<CameraService::BasicClient> CameraService::CameraClientManager::getCameraClient(
2918 const String8& id) const {
2919 auto descriptor = get(id);
2920 if (descriptor == nullptr) {
2921 return sp<BasicClient>{nullptr};
2922 }
2923 return descriptor->getValue();
2924}
2925
2926String8 CameraService::CameraClientManager::toString() const {
2927 auto all = getAll();
2928 String8 ret("[");
2929 bool hasAny = false;
2930 for (auto& i : all) {
2931 hasAny = true;
2932 String8 key = i->getKey();
2933 int32_t cost = i->getCost();
2934 int32_t pid = i->getOwnerId();
Emilian Peev8131a262017-02-01 12:33:43 +00002935 int32_t score = i->getPriority().getScore();
2936 int32_t state = i->getPriority().getState();
Ruben Brunkcc776712015-02-17 20:18:47 -08002937 auto conflicting = i->getConflicting();
2938 auto clientSp = i->getValue();
2939 String8 packageName;
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07002940 userid_t clientUserId = 0;
Ruben Brunkcc776712015-02-17 20:18:47 -08002941 if (clientSp.get() != nullptr) {
2942 packageName = String8{clientSp->getPackageName()};
Ruben Brunk6267b532015-04-30 17:44:07 -07002943 uid_t clientUid = clientSp->getClientUid();
2944 clientUserId = multiuser_get_user_id(clientUid);
Ruben Brunkcc776712015-02-17 20:18:47 -08002945 }
Emilian Peev8131a262017-02-01 12:33:43 +00002946 ret.appendFormat("\n(Camera ID: %s, Cost: %" PRId32 ", PID: %" PRId32 ", Score: %"
2947 PRId32 ", State: %" PRId32, key.string(), cost, pid, score, state);
Ruben Brunkcc776712015-02-17 20:18:47 -08002948
Ruben Brunk6267b532015-04-30 17:44:07 -07002949 if (clientSp.get() != nullptr) {
2950 ret.appendFormat("User Id: %d, ", clientUserId);
2951 }
Ruben Brunkcc776712015-02-17 20:18:47 -08002952 if (packageName.size() != 0) {
2953 ret.appendFormat("Client Package Name: %s", packageName.string());
2954 }
2955
2956 ret.append(", Conflicting Client Devices: {");
2957 for (auto& j : conflicting) {
2958 ret.appendFormat("%s, ", j.string());
2959 }
2960 ret.append("})");
2961 }
2962 if (hasAny) ret.append("\n");
2963 ret.append("]\n");
2964 return ret;
2965}
2966
2967CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2968 const String8& key, const sp<BasicClient>& value, int32_t cost,
Emilian Peev8131a262017-02-01 12:33:43 +00002969 const std::set<String8>& conflictingKeys, int32_t score, int32_t ownerId,
2970 int32_t state) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002971
2972 return std::make_shared<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>(
Emilian Peev8131a262017-02-01 12:33:43 +00002973 key, value, cost, conflictingKeys, score, ownerId, state);
Ruben Brunkcc776712015-02-17 20:18:47 -08002974}
2975
2976CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2977 const sp<BasicClient>& value, const CameraService::DescriptorPtr& partial) {
2978 return makeClientDescriptor(partial->getKey(), value, partial->getCost(),
Emilian Peev8131a262017-02-01 12:33:43 +00002979 partial->getConflicting(), partial->getPriority().getScore(),
2980 partial->getOwnerId(), partial->getPriority().getState());
Ruben Brunkcc776712015-02-17 20:18:47 -08002981}
2982
2983// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -07002984
2985static const int kDumpLockRetries = 50;
2986static const int kDumpLockSleep = 60000;
2987
2988static bool tryLock(Mutex& mutex)
2989{
2990 bool locked = false;
2991 for (int i = 0; i < kDumpLockRetries; ++i) {
2992 if (mutex.tryLock() == NO_ERROR) {
2993 locked = true;
2994 break;
2995 }
2996 usleep(kDumpLockSleep);
2997 }
2998 return locked;
2999}
3000
3001status_t CameraService::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07003002 ATRACE_CALL();
3003
Mathias Agopian65ab4712010-07-14 17:59:35 -07003004 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003005 dprintf(fd, "Permission Denial: can't dump CameraService from pid=%d, uid=%d\n",
Jayant Chowdhary12361932018-08-27 14:46:13 -07003006 CameraThreadState::getCallingPid(),
3007 CameraThreadState::getCallingUid());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003008 return NO_ERROR;
3009 }
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003010 bool locked = tryLock(mServiceLock);
3011 // failed to lock - CameraService is probably deadlocked
3012 if (!locked) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003013 dprintf(fd, "!! CameraService may be deadlocked !!\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003014 }
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003015
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003016 if (!mInitialized) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003017 dprintf(fd, "!! No camera HAL available !!\n");
Ruben Brunkf81648e2014-04-17 16:14:57 -07003018
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003019 // Dump event log for error information
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003020 dumpEventLog(fd);
Ruben Brunkcc776712015-02-17 20:18:47 -08003021
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003022 if (locked) mServiceLock.unlock();
3023 return NO_ERROR;
3024 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003025 dprintf(fd, "\n== Service global info: ==\n\n");
3026 dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08003027 dprintf(fd, "Number of normal camera devices: %zu\n", mNormalDeviceIds.size());
3028 for (size_t i = 0; i < mNormalDeviceIds.size(); i++) {
3029 dprintf(fd, " Device %zu maps to \"%s\"\n", i, mNormalDeviceIds[i].c_str());
3030 }
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003031 String8 activeClientString = mActiveClientManager.toString();
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003032 dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());
3033 dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003034
3035 dumpEventLog(fd);
3036
3037 bool stateLocked = tryLock(mCameraStatesLock);
3038 if (!stateLocked) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003039 dprintf(fd, "CameraStates in use, may be deadlocked\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003040 }
3041
Emilian Peevbd8c5032018-02-14 23:05:40 +00003042 int argSize = args.size();
3043 for (int i = 0; i < argSize; i++) {
3044 if (args[i] == TagMonitor::kMonitorOption) {
3045 if (i + 1 < argSize) {
3046 mMonitorTags = String8(args[i + 1]);
3047 }
3048 break;
3049 }
3050 }
3051
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003052 for (auto& state : mCameraStates) {
3053 String8 cameraId = state.first;
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003054
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003055 dprintf(fd, "== Camera device %s dynamic info: ==\n", cameraId.string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003056
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003057 CameraParameters p = state.second->getShimParams();
3058 if (!p.isEmpty()) {
3059 dprintf(fd, " Camera1 API shim is using parameters:\n ");
3060 p.dump(fd, args);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003061 }
3062
3063 auto clientDescriptor = mActiveClientManager.get(cameraId);
Zhijun He2f140ed2017-02-08 09:57:23 -08003064 if (clientDescriptor != nullptr) {
3065 dprintf(fd, " Device %s is open. Client instance dump:\n",
3066 cameraId.string());
3067 dprintf(fd, " Client priority score: %d state: %d\n",
3068 clientDescriptor->getPriority().getScore(),
3069 clientDescriptor->getPriority().getState());
3070 dprintf(fd, " Client PID: %d\n", clientDescriptor->getOwnerId());
3071
3072 auto client = clientDescriptor->getValue();
3073 dprintf(fd, " Client package: %s\n",
3074 String8(client->getPackageName()).string());
3075
3076 client->dumpClient(fd, args);
3077 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003078 dprintf(fd, " Device %s is closed, no client instance\n",
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003079 cameraId.string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003080 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003081
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003082 }
3083
3084 if (stateLocked) mCameraStatesLock.unlock();
3085
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003086 if (locked) mServiceLock.unlock();
3087
Emilian Peevf53f66e2017-04-11 14:29:43 +01003088 mCameraProviderManager->dump(fd, args);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003089
3090 dprintf(fd, "\n== Vendor tags: ==\n\n");
3091
3092 sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
3093 if (desc == NULL) {
Emilian Peev71c73a22017-03-21 16:35:51 +00003094 sp<VendorTagDescriptorCache> cache =
3095 VendorTagDescriptorCache::getGlobalVendorTagCache();
3096 if (cache == NULL) {
3097 dprintf(fd, "No vendor tags.\n");
3098 } else {
3099 cache->dump(fd, /*verbosity*/2, /*indentation*/2);
3100 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003101 } else {
3102 desc->dump(fd, /*verbosity*/2, /*indentation*/2);
3103 }
3104
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003105 // Dump camera traces if there were any
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003106 dprintf(fd, "\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003107 camera3::CameraTraces::dump(fd, args);
3108
3109 // Process dump arguments, if any
3110 int n = args.size();
3111 String16 verboseOption("-v");
3112 String16 unreachableOption("--unreachable");
3113 for (int i = 0; i < n; i++) {
3114 if (args[i] == verboseOption) {
3115 // change logging level
3116 if (i + 1 >= n) continue;
3117 String8 levelStr(args[i+1]);
3118 int level = atoi(levelStr.string());
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003119 dprintf(fd, "\nSetting log level to %d.\n", level);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003120 setLogLevel(level);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003121 } else if (args[i] == unreachableOption) {
3122 // Dump memory analysis
3123 // TODO - should limit be an argument parameter?
3124 UnreachableMemoryInfo info;
3125 bool success = GetUnreachableMemory(info, /*limit*/ 10000);
3126 if (!success) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003127 dprintf(fd, "\n== Unable to dump unreachable memory. "
3128 "Try disabling SELinux enforcement. ==\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003129 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003130 dprintf(fd, "\n== Dumping unreachable memory: ==\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003131 std::string s = info.ToString(/*log_contents*/ true);
3132 write(fd, s.c_str(), s.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003133 }
3134 }
3135 }
3136 return NO_ERROR;
3137}
3138
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003139void CameraService::dumpEventLog(int fd) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003140 dprintf(fd, "\n== Camera service events log (most recent at top): ==\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003141
3142 Mutex::Autolock l(mLogLock);
3143 for (const auto& msg : mEventLog) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003144 dprintf(fd, " %s\n", msg.string());
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003145 }
3146
3147 if (mEventLog.size() == DEFAULT_EVENT_LOG_LENGTH) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003148 dprintf(fd, " ...\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003149 } else if (mEventLog.size() == 0) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003150 dprintf(fd, " [no events yet]\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003151 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003152 dprintf(fd, "\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003153}
3154
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003155void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003156 Mutex::Autolock al(mTorchClientMapMutex);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003157 for (size_t i = 0; i < mTorchClientMap.size(); i++) {
3158 if (mTorchClientMap[i] == who) {
3159 // turn off the torch mode that was turned on by dead client
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003160 String8 cameraId = mTorchClientMap.keyAt(i);
3161 status_t res = mFlashlight->setTorchMode(cameraId, false);
3162 if (res) {
3163 ALOGE("%s: torch client died but couldn't turn off torch: "
3164 "%s (%d)", __FUNCTION__, strerror(-res), res);
3165 return;
3166 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003167 mTorchClientMap.removeItemsAt(i);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003168 break;
3169 }
3170 }
3171}
3172
Ruben Brunkcc776712015-02-17 20:18:47 -08003173/*virtual*/void CameraService::binderDied(const wp<IBinder> &who) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07003174
Igor Murashkin294d0ec2012-10-05 10:44:57 -07003175 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07003176 * While tempting to promote the wp<IBinder> into a sp, it's actually not supported by the
3177 * binder driver
Igor Murashkin294d0ec2012-10-05 10:44:57 -07003178 */
Yin-Chia Yehdbfcb382018-02-16 11:17:36 -08003179 // PID here is approximate and can be wrong.
Jayant Chowdhary12361932018-08-27 14:46:13 -07003180 logClientDied(CameraThreadState::getCallingPid(), String8("Binder died unexpectedly"));
Ruben Brunka8ca9152015-04-07 14:23:40 -07003181
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003182 // check torch client
3183 handleTorchClientBinderDied(who);
3184
3185 // check camera device client
Ruben Brunkcc776712015-02-17 20:18:47 -08003186 if(!evictClientIdByRemote(who)) {
3187 ALOGV("%s: Java client's binder death already cleaned up (normal case)", __FUNCTION__);
Igor Murashkinecf17e82012-10-02 16:05:11 -07003188 return;
3189 }
3190
Ruben Brunkcc776712015-02-17 20:18:47 -08003191 ALOGE("%s: Java client's binder died, removing it from the list of active clients",
3192 __FUNCTION__);
Igor Murashkinecf17e82012-10-02 16:05:11 -07003193}
3194
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003195void CameraService::updateStatus(StatusInternal status, const String8& cameraId) {
Ruben Brunkcc776712015-02-17 20:18:47 -08003196 updateStatus(status, cameraId, {});
Igor Murashkinbfc99152013-02-27 12:55:20 -08003197}
3198
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003199void CameraService::updateStatus(StatusInternal status, const String8& cameraId,
3200 std::initializer_list<StatusInternal> rejectSourceStates) {
Ruben Brunkcc776712015-02-17 20:18:47 -08003201 // Do not lock mServiceLock here or can get into a deadlock from
3202 // connect() -> disconnect -> updateStatus
3203
3204 auto state = getCameraState(cameraId);
3205
3206 if (state == nullptr) {
3207 ALOGW("%s: Could not update the status for %s, no such device exists", __FUNCTION__,
3208 cameraId.string());
3209 return;
Igor Murashkincba2c162013-03-20 15:56:31 -07003210 }
3211
Ruben Brunkcc776712015-02-17 20:18:47 -08003212 // Update the status for this camera state, then send the onStatusChangedCallbacks to each
3213 // of the listeners with both the mStatusStatus and mStatusListenerLock held
3214 state->updateStatus(status, cameraId, rejectSourceStates, [this]
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003215 (const String8& cameraId, StatusInternal status) {
Ruben Brunkcc776712015-02-17 20:18:47 -08003216
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003217 if (status != StatusInternal::ENUMERATING) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07003218 // Update torch status if it has a flash unit.
3219 Mutex::Autolock al(mTorchStatusMutex);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003220 TorchModeStatus torchStatus;
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07003221 if (getTorchStatusLocked(cameraId, &torchStatus) !=
3222 NAME_NOT_FOUND) {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003223 TorchModeStatus newTorchStatus =
3224 status == StatusInternal::PRESENT ?
3225 TorchModeStatus::AVAILABLE_OFF :
3226 TorchModeStatus::NOT_AVAILABLE;
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07003227 if (torchStatus != newTorchStatus) {
3228 onTorchStatusChangedLocked(cameraId, newTorchStatus);
3229 }
3230 }
Ruben Brunkcc776712015-02-17 20:18:47 -08003231 }
3232
3233 Mutex::Autolock lock(mStatusListenerLock);
3234
3235 for (auto& listener : mListenerList) {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08003236 if (!listener.first &&
3237 mCameraProviderManager->isPublicallyHiddenSecureCamera(cameraId.c_str())) {
3238 ALOGV("Skipping camera discovery callback for system-only camera %s",
3239 cameraId.c_str());
3240 continue;
3241 }
Emilian Peev53722fa2019-02-22 17:47:20 -08003242 listener.second->getListener()->onStatusChanged(mapToInterface(status),
3243 String16(cameraId));
Ruben Brunkcc776712015-02-17 20:18:47 -08003244 }
3245 });
Igor Murashkincba2c162013-03-20 15:56:31 -07003246}
3247
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003248template<class Func>
3249void CameraService::CameraState::updateStatus(StatusInternal status,
3250 const String8& cameraId,
3251 std::initializer_list<StatusInternal> rejectSourceStates,
3252 Func onStatusUpdatedLocked) {
3253 Mutex::Autolock lock(mStatusLock);
3254 StatusInternal oldStatus = mStatus;
3255 mStatus = status;
3256
3257 if (oldStatus == status) {
3258 return;
3259 }
3260
3261 ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
3262 cameraId.string(), oldStatus, status);
3263
3264 if (oldStatus == StatusInternal::NOT_PRESENT &&
3265 (status != StatusInternal::PRESENT &&
3266 status != StatusInternal::ENUMERATING)) {
3267
3268 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
3269 __FUNCTION__);
3270 mStatus = oldStatus;
3271 return;
3272 }
3273
3274 /**
3275 * Sometimes we want to conditionally do a transition.
3276 * For example if a client disconnects, we want to go to PRESENT
3277 * only if we weren't already in NOT_PRESENT or ENUMERATING.
3278 */
3279 for (auto& rejectStatus : rejectSourceStates) {
3280 if (oldStatus == rejectStatus) {
3281 ALOGV("%s: Rejecting status transition for Camera ID %s, since the source "
3282 "state was was in one of the bad states.", __FUNCTION__, cameraId.string());
3283 mStatus = oldStatus;
3284 return;
3285 }
3286 }
3287
3288 onStatusUpdatedLocked(cameraId, status);
3289}
3290
Eino-Ville Talvalae8c96c72017-06-27 12:24:07 -07003291void CameraService::updateProxyDeviceState(int newState,
Emilian Peev573291c2018-02-10 02:10:56 +00003292 const String8& cameraId, int facing, const String16& clientName, int apiLevel) {
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07003293 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
3294 if (proxyBinder == nullptr) return;
3295 String16 id(cameraId);
Emilian Peev573291c2018-02-10 02:10:56 +00003296 proxyBinder->notifyCameraState(id, newState, facing, clientName, apiLevel);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07003297}
3298
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003299status_t CameraService::getTorchStatusLocked(
3300 const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003301 TorchModeStatus *status) const {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003302 if (!status) {
3303 return BAD_VALUE;
3304 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003305 ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3306 if (index == NAME_NOT_FOUND) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003307 // invalid camera ID or the camera doesn't have a flash unit
3308 return NAME_NOT_FOUND;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003309 }
3310
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003311 *status = mTorchStatusMap.valueAt(index);
3312 return OK;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003313}
3314
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003315status_t CameraService::setTorchStatusLocked(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003316 TorchModeStatus status) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003317 ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3318 if (index == NAME_NOT_FOUND) {
3319 return BAD_VALUE;
3320 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003321 mTorchStatusMap.editValueAt(index) = status;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003322
3323 return OK;
3324}
3325
Svet Ganova453d0d2018-01-11 15:37:58 -08003326void CameraService::blockClientsForUid(uid_t uid) {
3327 const auto clients = mActiveClientManager.getAll();
3328 for (auto& current : clients) {
3329 if (current != nullptr) {
3330 const auto basicClient = current->getValue();
3331 if (basicClient.get() != nullptr && basicClient->getClientUid() == uid) {
3332 basicClient->block();
3333 }
3334 }
3335 }
3336}
3337
Michael Grooverd1d435a2018-12-18 17:39:42 -08003338void CameraService::blockAllClients() {
3339 const auto clients = mActiveClientManager.getAll();
3340 for (auto& current : clients) {
3341 if (current != nullptr) {
3342 const auto basicClient = current->getValue();
3343 if (basicClient.get() != nullptr) {
3344 basicClient->block();
3345 }
3346 }
3347 }
3348}
3349
Svet Ganova453d0d2018-01-11 15:37:58 -08003350// NOTE: This is a remote API - make sure all args are validated
3351status_t CameraService::shellCommand(int in, int out, int err, const Vector<String16>& args) {
3352 if (!checkCallingPermission(sManageCameraPermission, nullptr, nullptr)) {
3353 return PERMISSION_DENIED;
3354 }
3355 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
3356 return BAD_VALUE;
3357 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003358 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003359 return handleSetUidState(args, err);
Nicholas Sauera3620332019-04-03 14:05:17 -07003360 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003361 return handleResetUidState(args, err);
Nicholas Sauera3620332019-04-03 14:05:17 -07003362 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003363 return handleGetUidState(args, out, err);
3364 } else if (args.size() == 1 && args[0] == String16("help")) {
3365 printHelp(out);
3366 return NO_ERROR;
3367 }
3368 printHelp(err);
3369 return BAD_VALUE;
3370}
3371
3372status_t CameraService::handleSetUidState(const Vector<String16>& args, int err) {
Nicholas Sauera3620332019-04-03 14:05:17 -07003373 String16 packageName = args[1];
3374
Svet Ganova453d0d2018-01-11 15:37:58 -08003375 bool active = false;
3376 if (args[2] == String16("active")) {
3377 active = true;
3378 } else if ((args[2] != String16("idle"))) {
3379 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
3380 return BAD_VALUE;
3381 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003382
3383 int userId = 0;
3384 if (args.size() >= 5 && args[3] == String16("--user")) {
3385 userId = atoi(String8(args[4]));
3386 }
3387
3388 uid_t uid;
3389 if (getUidForPackage(packageName, userId, uid, err) == BAD_VALUE) {
3390 return BAD_VALUE;
3391 }
3392
3393 mUidPolicy->addOverrideUid(uid, packageName, active);
Svet Ganova453d0d2018-01-11 15:37:58 -08003394 return NO_ERROR;
3395}
3396
3397status_t CameraService::handleResetUidState(const Vector<String16>& args, int err) {
Nicholas Sauera3620332019-04-03 14:05:17 -07003398 String16 packageName = args[1];
3399
3400 int userId = 0;
3401 if (args.size() >= 4 && args[2] == String16("--user")) {
3402 userId = atoi(String8(args[3]));
3403 }
3404
3405 uid_t uid;
3406 if (getUidForPackage(packageName, userId, uid, err) == BAD_VALUE) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003407 return BAD_VALUE;
3408 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003409
3410 mUidPolicy->removeOverrideUid(uid, packageName);
Svet Ganova453d0d2018-01-11 15:37:58 -08003411 return NO_ERROR;
3412}
3413
3414status_t CameraService::handleGetUidState(const Vector<String16>& args, int out, int err) {
Nicholas Sauera3620332019-04-03 14:05:17 -07003415 String16 packageName = args[1];
3416
3417 int userId = 0;
3418 if (args.size() >= 4 && args[2] == String16("--user")) {
3419 userId = atoi(String8(args[3]));
3420 }
3421
3422 uid_t uid;
3423 if (getUidForPackage(packageName, userId, uid, err) == BAD_VALUE) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003424 return BAD_VALUE;
3425 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003426
3427 if (mUidPolicy->isUidActive(uid, packageName)) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003428 return dprintf(out, "active\n");
3429 } else {
3430 return dprintf(out, "idle\n");
3431 }
3432}
3433
3434status_t CameraService::printHelp(int out) {
3435 return dprintf(out, "Camera service commands:\n"
Nicholas Sauera3620332019-04-03 14:05:17 -07003436 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
3437 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
3438 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganova453d0d2018-01-11 15:37:58 -08003439 " help print this message\n");
3440}
3441
Mathias Agopian65ab4712010-07-14 17:59:35 -07003442}; // namespace android