blob: a87ebdf77036dac0b8a0ecb4732db204dccc3bce [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
Jayant Chowdharyc578a502019-05-08 10:57:54 -0700120// Matches with PERCEPTIBLE_APP_ADJ in ProcessList.java
121static constexpr int32_t kVendorClientScore = 200;
122// Matches with PROCESS_STATE_PERSISTENT_UI in ActivityManager.java
123static constexpr int32_t kVendorClientState = 1;
124
Eino-Ville Talvala7d5569f2019-04-08 13:57:54 -0700125Mutex CameraService::sProxyMutex;
126sp<hardware::ICameraServiceProxy> CameraService::sCameraServiceProxy;
127
Eino-Ville Talvala49c97052016-01-12 14:29:40 -0800128CameraService::CameraService() :
129 mEventLog(DEFAULT_EVENT_LOG_LENGTH),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800130 mNumberOfCameras(0),
Emilian Peevf53f66e2017-04-11 14:29:43 +0100131 mSoundRef(0), mInitialized(false) {
Steve Blockdf64d152012-01-04 20:05:49 +0000132 ALOGI("CameraService started (pid=%d)", getpid());
Ruben Brunkcc776712015-02-17 20:18:47 -0800133 mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700134}
135
Iliyan Malchev8951a972011-04-14 16:55:59 -0700136void CameraService::onFirstRef()
137{
Ruben Brunkcc776712015-02-17 20:18:47 -0800138 ALOGI("CameraService process starting");
Igor Murashkin634a5152013-02-20 17:15:11 -0800139
Iliyan Malchev8951a972011-04-14 16:55:59 -0700140 BnCameraService::onFirstRef();
141
Ruben Brunk99e69712015-05-26 17:25:07 -0700142 // Update battery life tracking if service is restarting
143 BatteryNotifier& notifier(BatteryNotifier::getInstance());
144 notifier.noteResetCamera();
145 notifier.noteResetFlashlight();
146
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800147 status_t res = INVALID_OPERATION;
Eino-Ville Talvala9cbbc832017-01-23 15:39:53 -0800148
Emilian Peevf53f66e2017-04-11 14:29:43 +0100149 res = enumerateProviders();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800150 if (res == OK) {
151 mInitialized = true;
152 }
153
154 CameraService::pingCameraServiceProxy();
Svet Ganova453d0d2018-01-11 15:37:58 -0800155
156 mUidPolicy = new UidPolicy(this);
157 mUidPolicy->registerSelf();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800158 mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
159 mSensorPrivacyPolicy->registerSelf();
Jayant Chowdharybe543d42018-08-15 13:16:14 -0700160 sp<HidlCameraService> hcs = HidlCameraService::getInstance(this);
161 if (hcs->registerAsService() != android::OK) {
162 ALOGE("%s: Failed to register default android.frameworks.cameraservice.service@1.0",
163 __FUNCTION__);
164 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800165}
166
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800167status_t CameraService::enumerateProviders() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800168 status_t res;
Emilian Peevaee727d2017-05-04 16:35:48 +0100169
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800170 std::vector<std::string> deviceIds;
171 {
172 Mutex::Autolock l(mServiceLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800173
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800174 if (nullptr == mCameraProviderManager.get()) {
175 mCameraProviderManager = new CameraProviderManager();
176 res = mCameraProviderManager->initialize(this);
177 if (res != OK) {
178 ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
179 __FUNCTION__, strerror(-res), res);
180 return res;
Emilian Peevaee727d2017-05-04 16:35:48 +0100181 }
182 }
183
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800184
185 // Setup vendor tags before we call get_camera_info the first time
186 // because HAL might need to setup static vendor keys in get_camera_info
187 // TODO: maybe put this into CameraProviderManager::initialize()?
188 mCameraProviderManager->setUpVendorTags();
189
190 if (nullptr == mFlashlight.get()) {
191 mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700192 }
193
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800194 res = mFlashlight->findFlashUnits();
195 if (res != OK) {
196 ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
197 }
198
199 deviceIds = mCameraProviderManager->getCameraDeviceIds();
200 }
201
202
203 for (auto& cameraId : deviceIds) {
204 String8 id8 = String8(cameraId.c_str());
Shuzhen Wang6ba3f5e2018-11-20 10:04:08 -0800205 if (getCameraState(id8) == nullptr) {
206 onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);
207 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800208 }
209
210 return OK;
211}
212
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700213sp<ICameraServiceProxy> CameraService::getCameraServiceProxy() {
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800214#ifndef __BRILLO__
Eino-Ville Talvala7d5569f2019-04-08 13:57:54 -0700215 Mutex::Autolock al(sProxyMutex);
216 if (sCameraServiceProxy == nullptr) {
217 sp<IServiceManager> sm = defaultServiceManager();
218 // Use checkService because cameraserver normally starts before the
219 // system server and the proxy service. So the long timeout that getService
220 // has before giving up is inappropriate.
221 sp<IBinder> binder = sm->checkService(String16("media.camera.proxy"));
222 if (binder != nullptr) {
223 sCameraServiceProxy = interface_cast<ICameraServiceProxy>(binder);
224 }
Ruben Brunk2823ce02015-05-19 17:25:13 -0700225 }
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800226#endif
Eino-Ville Talvala7d5569f2019-04-08 13:57:54 -0700227 return sCameraServiceProxy;
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700228}
229
230void CameraService::pingCameraServiceProxy() {
231 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
232 if (proxyBinder == nullptr) return;
Ruben Brunk2823ce02015-05-19 17:25:13 -0700233 proxyBinder->pingForUserUpdate();
Iliyan Malchev8951a972011-04-14 16:55:59 -0700234}
235
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800236void CameraService::broadcastTorchModeStatus(const String8& cameraId, TorchModeStatus status) {
237 Mutex::Autolock lock(mStatusListenerLock);
238
239 for (auto& i : mListenerList) {
Emilian Peev53722fa2019-02-22 17:47:20 -0800240 i.second->getListener()->onTorchStatusChanged(mapToInterface(status), String16{cameraId});
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800241 }
242}
243
Mathias Agopian65ab4712010-07-14 17:59:35 -0700244CameraService::~CameraService() {
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800245 VendorTagDescriptor::clearGlobalVendorTagDescriptor();
Svet Ganova453d0d2018-01-11 15:37:58 -0800246 mUidPolicy->unregisterSelf();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800247 mSensorPrivacyPolicy->unregisterSelf();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700248}
249
Emilian Peevaee727d2017-05-04 16:35:48 +0100250void CameraService::onNewProviderRegistered() {
251 enumerateProviders();
252}
253
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800254void CameraService::updateCameraNumAndIds() {
255 Mutex::Autolock l(mServiceLock);
256 mNumberOfCameras = mCameraProviderManager->getCameraCount();
257 mNormalDeviceIds =
258 mCameraProviderManager->getAPI1CompatibleCameraDeviceIds();
259}
260
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100261void CameraService::addStates(const String8 id) {
262 std::string cameraId(id.c_str());
263 hardware::camera::common::V1_0::CameraResourceCost cost;
264 status_t res = mCameraProviderManager->getResourceCost(cameraId, &cost);
265 if (res != OK) {
266 ALOGE("Failed to query device resource cost: %s (%d)", strerror(-res), res);
267 return;
268 }
269 std::set<String8> conflicting;
270 for (size_t i = 0; i < cost.conflictingDevices.size(); i++) {
271 conflicting.emplace(String8(cost.conflictingDevices[i].c_str()));
272 }
273
274 {
275 Mutex::Autolock lock(mCameraStatesLock);
276 mCameraStates.emplace(id, std::make_shared<CameraState>(id, cost.resourceCost,
277 conflicting));
278 }
279
280 if (mFlashlight->hasFlashUnit(id)) {
Emilian Peev7f25e5f2018-04-11 16:50:34 +0100281 Mutex::Autolock al(mTorchStatusMutex);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100282 mTorchStatusMap.add(id, TorchModeStatus::AVAILABLE_OFF);
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800283
284 broadcastTorchModeStatus(id, TorchModeStatus::AVAILABLE_OFF);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100285 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800286
287 updateCameraNumAndIds();
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100288 logDeviceAdded(id, "Device added");
289}
290
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100291void CameraService::removeStates(const String8 id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800292 updateCameraNumAndIds();
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100293 if (mFlashlight->hasFlashUnit(id)) {
Emilian Peev7f25e5f2018-04-11 16:50:34 +0100294 Mutex::Autolock al(mTorchStatusMutex);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100295 mTorchStatusMap.removeItem(id);
296 }
297
298 {
299 Mutex::Autolock lock(mCameraStatesLock);
300 mCameraStates.erase(id);
301 }
302}
303
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800304void CameraService::onDeviceStatusChanged(const String8& id,
305 CameraDeviceStatus newHalStatus) {
306 ALOGI("%s: Status changed for cameraId=%s, newStatus=%d", __FUNCTION__,
307 id.string(), newHalStatus);
Igor Murashkincba2c162013-03-20 15:56:31 -0700308
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800309 StatusInternal newStatus = mapToInternal(newHalStatus);
310
Ruben Brunkcc776712015-02-17 20:18:47 -0800311 std::shared_ptr<CameraState> state = getCameraState(id);
312
313 if (state == nullptr) {
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700314 if (newStatus == StatusInternal::PRESENT) {
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100315 ALOGI("%s: Unknown camera ID %s, a new camera is added",
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700316 __FUNCTION__, id.string());
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100317
318 // First add as absent to make sure clients are notified below
319 addStates(id);
320
321 updateStatus(newStatus, id);
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700322 } else {
323 ALOGE("%s: Bad camera ID %s", __FUNCTION__, id.string());
324 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700325 return;
326 }
327
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800328 StatusInternal oldStatus = state->getStatus();
Ruben Brunkcc776712015-02-17 20:18:47 -0800329
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800330 if (oldStatus == newStatus) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800331 ALOGE("%s: State transition to the same status %#x not allowed", __FUNCTION__, newStatus);
Igor Murashkincba2c162013-03-20 15:56:31 -0700332 return;
333 }
334
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800335 if (newStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunka8ca9152015-04-07 14:23:40 -0700336 logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus,
337 newStatus));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800338
339 // Set the device status to NOT_PRESENT, clients will no longer be able to connect
340 // to this device until the status changes
341 updateStatus(StatusInternal::NOT_PRESENT, id);
342
Ruben Brunkcc776712015-02-17 20:18:47 -0800343 sp<BasicClient> clientToDisconnect;
Igor Murashkincba2c162013-03-20 15:56:31 -0700344 {
Ruben Brunkcc776712015-02-17 20:18:47 -0800345 // Don't do this in updateStatus to avoid deadlock over mServiceLock
346 Mutex::Autolock lock(mServiceLock);
Igor Murashkincba2c162013-03-20 15:56:31 -0700347
Ruben Brunkcc776712015-02-17 20:18:47 -0800348 // Remove cached shim parameters
349 state->setShimParams(CameraParameters());
Igor Murashkincba2c162013-03-20 15:56:31 -0700350
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700351 // Remove the client from the list of active clients, if there is one
Ruben Brunkcc776712015-02-17 20:18:47 -0800352 clientToDisconnect = removeClientLocked(id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700353 }
Ruben Brunkcc776712015-02-17 20:18:47 -0800354
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700355 // Disconnect client
356 if (clientToDisconnect.get() != nullptr) {
357 ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL",
358 __FUNCTION__, id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -0800359 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800360 clientToDisconnect->notifyError(
361 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -0800362 CaptureResultExtras{});
Ruben Brunkcc776712015-02-17 20:18:47 -0800363 // Ensure not in binder RPC so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -0700364 LOG_ALWAYS_FATAL_IF(CameraThreadState::getCallingPid() != getpid(),
Ruben Brunkcc776712015-02-17 20:18:47 -0800365 "onDeviceStatusChanged must be called from the camera service process!");
366 clientToDisconnect->disconnect();
Igor Murashkincba2c162013-03-20 15:56:31 -0700367 }
368
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100369 removeStates(id);
Ruben Brunkcc776712015-02-17 20:18:47 -0800370 } else {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800371 if (oldStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunka8ca9152015-04-07 14:23:40 -0700372 logDeviceAdded(id, String8::format("Device status changed from %d to %d", oldStatus,
373 newStatus));
374 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800375 updateStatus(newStatus, id);
Igor Murashkincba2c162013-03-20 15:56:31 -0700376 }
377
Igor Murashkincba2c162013-03-20 15:56:31 -0700378}
379
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800380void CameraService::onTorchStatusChanged(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800381 TorchModeStatus newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800382 Mutex::Autolock al(mTorchStatusMutex);
383 onTorchStatusChangedLocked(cameraId, newStatus);
384}
385
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800386void CameraService::onTorchStatusChangedLocked(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800387 TorchModeStatus newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800388 ALOGI("%s: Torch status changed for cameraId=%s, newStatus=%d",
389 __FUNCTION__, cameraId.string(), newStatus);
390
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800391 TorchModeStatus status;
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800392 status_t res = getTorchStatusLocked(cameraId, &status);
393 if (res) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -0700394 ALOGE("%s: cannot get torch status of camera %s: %s (%d)",
395 __FUNCTION__, cameraId.string(), strerror(-res), res);
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800396 return;
397 }
398 if (status == newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800399 return;
400 }
401
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800402 res = setTorchStatusLocked(cameraId, newStatus);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800403 if (res) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800404 ALOGE("%s: Failed to set the torch status to %d: %s (%d)", __FUNCTION__,
405 (uint32_t)newStatus, strerror(-res), res);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800406 return;
407 }
408
Ruben Brunkcc776712015-02-17 20:18:47 -0800409 {
Ruben Brunk99e69712015-05-26 17:25:07 -0700410 // Update battery life logging for flashlight
Chien-Yu Chenfe751be2015-09-01 14:16:44 -0700411 Mutex::Autolock al(mTorchUidMapMutex);
Ruben Brunk99e69712015-05-26 17:25:07 -0700412 auto iter = mTorchUidMap.find(cameraId);
413 if (iter != mTorchUidMap.end()) {
414 int oldUid = iter->second.second;
415 int newUid = iter->second.first;
416 BatteryNotifier& notifier(BatteryNotifier::getInstance());
417 if (oldUid != newUid) {
418 // If the UID has changed, log the status and update current UID in mTorchUidMap
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800419 if (status == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700420 notifier.noteFlashlightOff(cameraId, oldUid);
421 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800422 if (newStatus == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700423 notifier.noteFlashlightOn(cameraId, newUid);
424 }
425 iter->second.second = newUid;
426 } else {
427 // If the UID has not changed, log the status
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800428 if (newStatus == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700429 notifier.noteFlashlightOn(cameraId, oldUid);
430 } else {
431 notifier.noteFlashlightOff(cameraId, oldUid);
432 }
433 }
434 }
435 }
436
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800437 broadcastTorchModeStatus(cameraId, newStatus);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800438}
439
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800440Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700441 ATRACE_CALL();
Emilian Peevaee727d2017-05-04 16:35:48 +0100442 Mutex::Autolock l(mServiceLock);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700443 switch (type) {
444 case CAMERA_TYPE_BACKWARD_COMPATIBLE:
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800445 *numCameras = static_cast<int>(mNormalDeviceIds.size());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800446 break;
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700447 case CAMERA_TYPE_ALL:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800448 *numCameras = mNumberOfCameras;
449 break;
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700450 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800451 ALOGW("%s: Unknown camera type %d",
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700452 __FUNCTION__, type);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800453 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
454 "Unknown camera type %d", type);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700455 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800456 return Status::ok();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700457}
458
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800459Status CameraService::getCameraInfo(int cameraId,
460 CameraInfo* cameraInfo) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700461 ATRACE_CALL();
Emilian Peevaee727d2017-05-04 16:35:48 +0100462 Mutex::Autolock l(mServiceLock);
463
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800464 if (!mInitialized) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800465 return STATUS_ERROR(ERROR_DISCONNECTED,
466 "Camera subsystem is not available");
Iliyan Malchev8951a972011-04-14 16:55:59 -0700467 }
468
Mathias Agopian65ab4712010-07-14 17:59:35 -0700469 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800470 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
471 "CameraId is not valid");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700472 }
473
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800474 Status ret = Status::ok();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800475 status_t err = mCameraProviderManager->getCameraInfo(
476 cameraIdIntToStrLocked(cameraId), cameraInfo);
Emilian Peevf53f66e2017-04-11 14:29:43 +0100477 if (err != OK) {
478 ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
479 "Error retrieving camera info from device %d: %s (%d)", cameraId,
480 strerror(-err), err);
Ruben Brunkcc776712015-02-17 20:18:47 -0800481 }
Emilian Peevf53f66e2017-04-11 14:29:43 +0100482
Ruben Brunkcc776712015-02-17 20:18:47 -0800483 return ret;
484}
Ruben Brunkb2119af2014-05-09 19:57:56 -0700485
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800486std::string CameraService::cameraIdIntToStrLocked(int cameraIdInt) {
487 if (cameraIdInt < 0 || cameraIdInt >= static_cast<int>(mNormalDeviceIds.size())) {
488 ALOGE("%s: input id %d invalid: valid range (0, %zu)",
489 __FUNCTION__, cameraIdInt, mNormalDeviceIds.size());
490 return std::string{};
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800491 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800492
493 return mNormalDeviceIds[cameraIdInt];
494}
495
496String8 CameraService::cameraIdIntToStr(int cameraIdInt) {
497 Mutex::Autolock lock(mServiceLock);
498 return String8(cameraIdIntToStrLocked(cameraIdInt).c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800499}
500
501Status CameraService::getCameraCharacteristics(const String16& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800502 CameraMetadata* cameraInfo) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700503 ATRACE_CALL();
Zhijun He2b59be82013-09-25 10:14:30 -0700504 if (!cameraInfo) {
505 ALOGE("%s: cameraInfo is NULL", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800506 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "cameraInfo is NULL");
Zhijun He2b59be82013-09-25 10:14:30 -0700507 }
508
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800509 if (!mInitialized) {
510 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800511 return STATUS_ERROR(ERROR_DISCONNECTED,
512 "Camera subsystem is not available");;
Zhijun He2b59be82013-09-25 10:14:30 -0700513 }
514
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800515 Status ret{};
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800516
Emilian Peevf53f66e2017-04-11 14:29:43 +0100517 status_t res = mCameraProviderManager->getCameraCharacteristics(
518 String8(cameraId).string(), cameraInfo);
519 if (res != OK) {
520 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Unable to retrieve camera "
521 "characteristics for device %s: %s (%d)", String8(cameraId).string(),
522 strerror(-res), res);
Ruben Brunkb2119af2014-05-09 19:57:56 -0700523 }
Zhijun He2b59be82013-09-25 10:14:30 -0700524
Jayant Chowdhary12361932018-08-27 14:46:13 -0700525 int callingPid = CameraThreadState::getCallingPid();
526 int callingUid = CameraThreadState::getCallingUid();
Emilian Peeve20c6372018-08-14 18:45:53 +0100527 std::vector<int32_t> tagsRemoved;
528 // If it's not calling from cameraserver, check the permission.
529 if ((callingPid != getpid()) &&
530 !checkPermission(String16("android.permission.CAMERA"), callingPid, callingUid)) {
531 res = cameraInfo->removePermissionEntries(
532 mCameraProviderManager->getProviderTagIdLocked(String8(cameraId).string()),
533 &tagsRemoved);
534 if (res != OK) {
535 cameraInfo->clear();
536 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to remove camera"
537 " characteristics needing camera permission for device %s: %s (%d)",
538 String8(cameraId).string(), strerror(-res), res);
539 }
540 }
541
542 if (!tagsRemoved.empty()) {
543 res = cameraInfo->update(ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION,
544 tagsRemoved.data(), tagsRemoved.size());
545 if (res != OK) {
546 cameraInfo->clear();
547 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to insert camera "
548 "keys needing permission for device %s: %s (%d)", String8(cameraId).string(),
549 strerror(-res), res);
550 }
551 }
552
Zhijun He2b59be82013-09-25 10:14:30 -0700553 return ret;
554}
555
Ruben Brunkcc776712015-02-17 20:18:47 -0800556String8 CameraService::getFormattedCurrentTime() {
557 time_t now = time(nullptr);
558 char formattedTime[64];
559 strftime(formattedTime, sizeof(formattedTime), "%m-%d %H:%M:%S", localtime(&now));
560 return String8(formattedTime);
561}
562
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800563Status CameraService::getCameraVendorTagDescriptor(
564 /*out*/
565 hardware::camera2::params::VendorTagDescriptor* desc) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700566 ATRACE_CALL();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800567 if (!mInitialized) {
568 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800569 return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available");
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800570 }
Eino-Ville Talvala1e74e242016-03-03 11:24:28 -0800571 sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor();
572 if (globalDescriptor != nullptr) {
573 *desc = *(globalDescriptor.get());
574 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800575 return Status::ok();
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800576}
577
Emilian Peev71c73a22017-03-21 16:35:51 +0000578Status CameraService::getCameraVendorTagCache(
579 /*out*/ hardware::camera2::params::VendorTagDescriptorCache* cache) {
580 ATRACE_CALL();
581 if (!mInitialized) {
582 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
583 return STATUS_ERROR(ERROR_DISCONNECTED,
584 "Camera subsystem not available");
585 }
586 sp<VendorTagDescriptorCache> globalCache =
587 VendorTagDescriptorCache::getGlobalVendorTagCache();
588 if (globalCache != nullptr) {
589 *cache = *(globalCache.get());
590 }
591 return Status::ok();
592}
593
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800594int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700595 ATRACE_CALL();
Igor Murashkin634a5152013-02-20 17:15:11 -0800596
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800597 int deviceVersion = 0;
598
Emilian Peevf53f66e2017-04-11 14:29:43 +0100599 status_t res;
600 hardware::hidl_version maxVersion{0,0};
601 res = mCameraProviderManager->getHighestSupportedVersion(cameraId.string(),
602 &maxVersion);
603 if (res != OK) return -1;
604 deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800605
Emilian Peevf53f66e2017-04-11 14:29:43 +0100606 hardware::CameraInfo info;
607 if (facing) {
608 res = mCameraProviderManager->getCameraInfo(cameraId.string(), &info);
Eino-Ville Talvala6963d0a2017-01-31 13:00:34 -0800609 if (res != OK) return -1;
Emilian Peevf53f66e2017-04-11 14:29:43 +0100610 *facing = info.facing;
Igor Murashkin634a5152013-02-20 17:15:11 -0800611 }
Emilian Peevf53f66e2017-04-11 14:29:43 +0100612
Igor Murashkin634a5152013-02-20 17:15:11 -0800613 return deviceVersion;
614}
615
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800616Status CameraService::filterGetInfoErrorCode(status_t err) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700617 switch(err) {
618 case NO_ERROR:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800619 return Status::ok();
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800620 case BAD_VALUE:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800621 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
622 "CameraId is not valid for HAL module");
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800623 case NO_INIT:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800624 return STATUS_ERROR(ERROR_DISCONNECTED,
625 "Camera device not available");
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700626 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800627 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
628 "Camera HAL encountered error %d: %s",
629 err, strerror(-err));
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700630 }
Igor Murashkinbfc99152013-02-27 12:55:20 -0800631}
632
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800633Status CameraService::makeClient(const sp<CameraService>& cameraService,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800634 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800635 int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700636 int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
Ruben Brunkcc776712015-02-17 20:18:47 -0800637 /*out*/sp<BasicClient>* client) {
638
Ruben Brunkcc776712015-02-17 20:18:47 -0800639 if (halVersion < 0 || halVersion == deviceVersion) {
640 // Default path: HAL version is unspecified by caller, create CameraClient
641 // based on device version reported by the HAL.
642 switch(deviceVersion) {
643 case CAMERA_DEVICE_API_VERSION_1_0:
644 if (effectiveApiLevel == API_1) { // Camera1 API route
645 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800646 *client = new CameraClient(cameraService, tmp, packageName,
647 api1CameraId, facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700648 getpid());
Ruben Brunkcc776712015-02-17 20:18:47 -0800649 } else { // Camera2 API route
650 ALOGW("Camera using old HAL version: %d", deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800651 return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800652 "Camera device \"%s\" HAL version %d does not support camera2 API",
653 cameraId.string(), deviceVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800654 }
655 break;
Ruben Brunkcc776712015-02-17 20:18:47 -0800656 case CAMERA_DEVICE_API_VERSION_3_0:
657 case CAMERA_DEVICE_API_VERSION_3_1:
658 case CAMERA_DEVICE_API_VERSION_3_2:
659 case CAMERA_DEVICE_API_VERSION_3_3:
Zhijun He4afbdec2016-05-04 15:42:51 -0700660 case CAMERA_DEVICE_API_VERSION_3_4:
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700661 case CAMERA_DEVICE_API_VERSION_3_5:
Ruben Brunkcc776712015-02-17 20:18:47 -0800662 if (effectiveApiLevel == API_1) { // Camera1 API route
663 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800664 *client = new Camera2Client(cameraService, tmp, packageName,
665 cameraId, api1CameraId,
666 facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700667 servicePid);
Ruben Brunkcc776712015-02-17 20:18:47 -0800668 } else { // Camera2 API route
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800669 sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
670 static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
671 *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
Ruben Brunkcc776712015-02-17 20:18:47 -0800672 facing, clientPid, clientUid, servicePid);
673 }
674 break;
675 default:
676 // Should not be reachable
677 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800678 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800679 "Camera device \"%s\" has unknown HAL version %d",
680 cameraId.string(), deviceVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800681 }
682 } else {
683 // A particular HAL version is requested by caller. Create CameraClient
684 // based on the requested HAL version.
685 if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
686 halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
687 // Only support higher HAL version device opened as HAL1.0 device.
688 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800689 *client = new CameraClient(cameraService, tmp, packageName,
690 api1CameraId, facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700691 servicePid);
Ruben Brunkcc776712015-02-17 20:18:47 -0800692 } else {
693 // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
694 ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
695 " opened as HAL %x device", halVersion, deviceVersion,
696 CAMERA_DEVICE_API_VERSION_1_0);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800697 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800698 "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
699 cameraId.string(), deviceVersion, halVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800700 }
701 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800702 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800703}
704
Ruben Brunk6267b532015-04-30 17:44:07 -0700705String8 CameraService::toString(std::set<userid_t> intSet) {
706 String8 s("");
707 bool first = true;
708 for (userid_t i : intSet) {
709 if (first) {
710 s.appendFormat("%d", i);
711 first = false;
712 } else {
713 s.appendFormat(", %d", i);
714 }
715 }
716 return s;
717}
718
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800719int32_t CameraService::mapToInterface(TorchModeStatus status) {
720 int32_t serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
721 switch (status) {
722 case TorchModeStatus::NOT_AVAILABLE:
723 serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
724 break;
725 case TorchModeStatus::AVAILABLE_OFF:
726 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF;
727 break;
728 case TorchModeStatus::AVAILABLE_ON:
729 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON;
730 break;
731 default:
732 ALOGW("Unknown new flash status: %d", status);
733 }
734 return serviceStatus;
735}
736
737CameraService::StatusInternal CameraService::mapToInternal(CameraDeviceStatus status) {
738 StatusInternal serviceStatus = StatusInternal::NOT_PRESENT;
739 switch (status) {
740 case CameraDeviceStatus::NOT_PRESENT:
741 serviceStatus = StatusInternal::NOT_PRESENT;
742 break;
743 case CameraDeviceStatus::PRESENT:
744 serviceStatus = StatusInternal::PRESENT;
745 break;
746 case CameraDeviceStatus::ENUMERATING:
747 serviceStatus = StatusInternal::ENUMERATING;
748 break;
749 default:
750 ALOGW("Unknown new HAL device status: %d", status);
751 }
752 return serviceStatus;
753}
754
755int32_t CameraService::mapToInterface(StatusInternal status) {
756 int32_t serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
757 switch (status) {
758 case StatusInternal::NOT_PRESENT:
759 serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
760 break;
761 case StatusInternal::PRESENT:
762 serviceStatus = ICameraServiceListener::STATUS_PRESENT;
763 break;
764 case StatusInternal::ENUMERATING:
765 serviceStatus = ICameraServiceListener::STATUS_ENUMERATING;
766 break;
767 case StatusInternal::NOT_AVAILABLE:
768 serviceStatus = ICameraServiceListener::STATUS_NOT_AVAILABLE;
769 break;
770 case StatusInternal::UNKNOWN:
771 serviceStatus = ICameraServiceListener::STATUS_UNKNOWN;
772 break;
773 default:
774 ALOGW("Unknown new internal device status: %d", status);
775 }
776 return serviceStatus;
777}
778
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800779Status CameraService::initializeShimMetadata(int cameraId) {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700780 int uid = CameraThreadState::getCallingUid();
Ruben Brunkb2119af2014-05-09 19:57:56 -0700781
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800782 String16 internalPackageName("cameraserver");
Ruben Brunkcc776712015-02-17 20:18:47 -0800783 String8 id = String8::format("%d", cameraId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800784 Status ret = Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800785 sp<Client> tmp = nullptr;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800786 if (!(ret = connectHelper<ICameraClient,Client>(
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800787 sp<ICameraClient>{nullptr}, id, cameraId,
788 static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800789 internalPackageName, uid, USE_CALLING_PID,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700790 API_1, /*shimUpdateOnly*/ true, /*out*/ tmp)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800791 ).isOk()) {
792 ALOGE("%s: Error initializing shim metadata: %s", __FUNCTION__, ret.toString8().string());
Ruben Brunkb2119af2014-05-09 19:57:56 -0700793 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800794 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700795}
796
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800797Status CameraService::getLegacyParametersLazy(int cameraId,
Igor Murashkin65d14b92014-06-17 12:03:20 -0700798 /*out*/
799 CameraParameters* parameters) {
800
801 ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId);
802
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800803 Status ret = Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -0700804
805 if (parameters == NULL) {
806 ALOGE("%s: parameters must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800807 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
Igor Murashkin65d14b92014-06-17 12:03:20 -0700808 }
809
Ruben Brunkcc776712015-02-17 20:18:47 -0800810 String8 id = String8::format("%d", cameraId);
811
812 // Check if we already have parameters
813 {
814 // Scope for service lock
Igor Murashkin65d14b92014-06-17 12:03:20 -0700815 Mutex::Autolock lock(mServiceLock);
Ruben Brunkcc776712015-02-17 20:18:47 -0800816 auto cameraState = getCameraState(id);
817 if (cameraState == nullptr) {
818 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800819 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
820 "Invalid camera ID: %s", id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -0800821 }
822 CameraParameters p = cameraState->getShimParams();
823 if (!p.isEmpty()) {
824 *parameters = p;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800825 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700826 }
827 }
828
Jayant Chowdhary12361932018-08-27 14:46:13 -0700829 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunkcc776712015-02-17 20:18:47 -0800830 ret = initializeShimMetadata(cameraId);
Jayant Chowdhary12361932018-08-27 14:46:13 -0700831 CameraThreadState::restoreCallingIdentity(token);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800832 if (!ret.isOk()) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800833 // Error already logged by callee
834 return ret;
835 }
836
837 // Check for parameters again
838 {
839 // Scope for service lock
840 Mutex::Autolock lock(mServiceLock);
841 auto cameraState = getCameraState(id);
842 if (cameraState == nullptr) {
843 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800844 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
845 "Invalid camera ID: %s", id.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -0700846 }
Ruben Brunkcc776712015-02-17 20:18:47 -0800847 CameraParameters p = cameraState->getShimParams();
848 if (!p.isEmpty()) {
849 *parameters = p;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800850 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700851 }
852 }
853
Ruben Brunkcc776712015-02-17 20:18:47 -0800854 ALOGE("%s: Parameters were not initialized, or were empty. Device may not be present.",
855 __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800856 return STATUS_ERROR(ERROR_INVALID_OPERATION, "Unable to initialize legacy parameters");
Igor Murashkin65d14b92014-06-17 12:03:20 -0700857}
858
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800859// Can camera service trust the caller based on the calling UID?
860static bool isTrustedCallingUid(uid_t uid) {
861 switch (uid) {
Eino-Ville Talvalaaf9d0302016-06-29 14:40:10 -0700862 case AID_MEDIA: // mediaserver
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800863 case AID_CAMERASERVER: // cameraserver
Eino-Ville Talvalaaf9d0302016-06-29 14:40:10 -0700864 case AID_RADIO: // telephony
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800865 return true;
866 default:
867 return false;
868 }
869}
870
Nicholas Sauera3620332019-04-03 14:05:17 -0700871static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
872 PermissionController pc;
873 uid = pc.getPackageUid(packageName, 0);
874 if (uid <= 0) {
875 ALOGE("Unknown package: '%s'", String8(packageName).string());
876 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
877 return BAD_VALUE;
878 }
879
880 if (userId < 0) {
881 ALOGE("Invalid user: %d", userId);
882 dprintf(err, "Invalid user: %d\n", userId);
883 return BAD_VALUE;
884 }
885
886 uid = multiuser_get_uid(userId, uid);
887 return NO_ERROR;
888}
889
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800890Status CameraService::validateConnectLocked(const String8& cameraId,
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700891 const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid,
892 /*out*/int& originalClientPid) const {
Tyler Luu5861a9a2011-10-06 00:00:03 -0500893
Alex Deymo9c2a2c22016-08-25 11:59:14 -0700894#ifdef __BRILLO__
895 UNUSED(clientName8);
896 UNUSED(clientUid);
897 UNUSED(clientPid);
898 UNUSED(originalClientPid);
899#else
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700900 Status allowed = validateClientPermissionsLocked(cameraId, clientName8, clientUid, clientPid,
901 originalClientPid);
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800902 if (!allowed.isOk()) {
Christopher Wileyce761d12016-02-16 10:15:00 -0800903 return allowed;
904 }
Alex Deymo9c2a2c22016-08-25 11:59:14 -0700905#endif // __BRILLO__
Christopher Wileyce761d12016-02-16 10:15:00 -0800906
Jayant Chowdhary12361932018-08-27 14:46:13 -0700907 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800908
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800909 if (!mInitialized) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800910 ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)",
911 callingPid);
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800912 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
913 "No camera HAL module available to open camera device \"%s\"", cameraId.string());
Iliyan Malchev8951a972011-04-14 16:55:59 -0700914 }
915
Ruben Brunkcc776712015-02-17 20:18:47 -0800916 if (getCameraState(cameraId) == nullptr) {
917 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
918 cameraId.string());
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800919 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
920 "No camera device with ID \"%s\" available", cameraId.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700921 }
922
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800923 status_t err = checkIfDeviceIsUsable(cameraId);
924 if (err != NO_ERROR) {
925 switch(err) {
926 case -ENODEV:
927 case -EBUSY:
928 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
929 "No camera device with ID \"%s\" currently available", cameraId.string());
930 default:
931 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
932 "Unknown error connecting to ID \"%s\"", cameraId.string());
933 }
934 }
935 return Status::ok();
Christopher Wiley0039bcf2016-02-05 10:29:50 -0800936}
937
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800938Status CameraService::validateClientPermissionsLocked(const String8& cameraId,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700939 const String8& clientName8, int& clientUid, int& clientPid,
940 /*out*/int& originalClientPid) const {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700941 int callingPid = CameraThreadState::getCallingPid();
942 int callingUid = CameraThreadState::getCallingUid();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700943
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800944 // Check if we can trust clientUid
Mathias Agopian65ab4712010-07-14 17:59:35 -0700945 if (clientUid == USE_CALLING_UID) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800946 clientUid = callingUid;
947 } else if (!isTrustedCallingUid(callingUid)) {
948 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
949 "(don't trust clientUid %d)", callingPid, callingUid, clientUid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800950 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
951 "Untrusted caller (calling PID %d, UID %d) trying to "
952 "forward camera access to camera %s for client %s (PID %d, UID %d)",
953 callingPid, callingUid, cameraId.string(),
954 clientName8.string(), clientUid, clientPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700955 }
956
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800957 // Check if we can trust clientPid
958 if (clientPid == USE_CALLING_PID) {
959 clientPid = callingPid;
960 } else if (!isTrustedCallingUid(callingUid)) {
961 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
962 "(don't trust clientPid %d)", callingPid, callingUid, clientPid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800963 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
964 "Untrusted caller (calling PID %d, UID %d) trying to "
965 "forward camera access to camera %s for client %s (PID %d, UID %d)",
966 callingPid, callingUid, cameraId.string(),
967 clientName8.string(), clientUid, clientPid);
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800968 }
969
970 // If it's not calling from cameraserver, check the permission.
971 if (callingPid != getpid() &&
972 !checkPermission(String16("android.permission.CAMERA"), clientPid, clientUid)) {
973 ALOGE("Permission Denial: can't use the camera pid=%d, uid=%d", clientPid, clientUid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800974 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
975 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" without camera permission",
976 clientName8.string(), clientUid, clientPid, cameraId.string());
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800977 }
978
Svet Ganova453d0d2018-01-11 15:37:58 -0800979 // Make sure the UID is in an active state to use the camera
Svet Ganov7b4ab782018-03-25 12:48:10 -0700980 if (!mUidPolicy->isUidActive(callingUid, String16(clientName8))) {
Varun Shahb42f1eb2019-04-16 14:45:13 -0700981 int32_t procState = mUidPolicy->getProcState(callingUid);
Svet Ganova453d0d2018-01-11 15:37:58 -0800982 ALOGE("Access Denial: can't use the camera from an idle UID pid=%d, uid=%d",
983 clientPid, clientUid);
984 return STATUS_ERROR_FMT(ERROR_DISABLED,
Varun Shahb42f1eb2019-04-16 14:45:13 -0700985 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" from background ("
986 "calling UID %d proc state %" PRId32 ")",
987 clientName8.string(), clientUid, clientPid, cameraId.string(),
988 callingUid, procState);
Svet Ganova453d0d2018-01-11 15:37:58 -0800989 }
990
Michael Grooverd1d435a2018-12-18 17:39:42 -0800991 // If sensor privacy is enabled then prevent access to the camera
992 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
993 ALOGE("Access Denial: cannot use the camera when sensor privacy is enabled");
994 return STATUS_ERROR_FMT(ERROR_DISABLED,
995 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" when sensor privacy "
996 "is enabled", clientName8.string(), clientUid, clientPid, cameraId.string());
997 }
998
Chien-Yu Chen4f3d6202016-03-22 10:50:23 -0700999 // Only use passed in clientPid to check permission. Use calling PID as the client PID that's
1000 // connected to camera service directly.
Chien-Yu Chen18df60e2016-03-18 18:18:09 -07001001 originalClientPid = clientPid;
Chien-Yu Chen4f3d6202016-03-22 10:50:23 -07001002 clientPid = callingPid;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001003
Ruben Brunk6267b532015-04-30 17:44:07 -07001004 userid_t clientUserId = multiuser_get_user_id(clientUid);
Wu-cheng Lia3355432011-05-20 14:54:25 +08001005
Ruben Brunka8ca9152015-04-07 14:23:40 -07001006 // Only allow clients who are being used by the current foreground device user, unless calling
Jayant Chowdhary8ec41c12019-02-21 20:17:22 -08001007 // from our own process OR the caller is using the cameraserver's HIDL interface.
1008 if (!hardware::IPCThreadState::self()->isServingCall() && callingPid != getpid() &&
1009 (mAllowedUsers.find(clientUserId) == mAllowedUsers.end())) {
Ruben Brunk6267b532015-04-30 17:44:07 -07001010 ALOGE("CameraService::connect X (PID %d) rejected (cannot connect from "
1011 "device user %d, currently allowed device users: %s)", callingPid, clientUserId,
1012 toString(mAllowedUsers).string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001013 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1014 "Callers from device user %d are not currently allowed to connect to camera \"%s\"",
1015 clientUserId, cameraId.string());
Ruben Brunk36597b22015-03-20 22:15:57 -07001016 }
1017
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001018 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001019}
1020
1021status_t CameraService::checkIfDeviceIsUsable(const String8& cameraId) const {
1022 auto cameraState = getCameraState(cameraId);
Jayant Chowdhary12361932018-08-27 14:46:13 -07001023 int callingPid = CameraThreadState::getCallingPid();
Ruben Brunkcc776712015-02-17 20:18:47 -08001024 if (cameraState == nullptr) {
1025 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
1026 cameraId.string());
1027 return -ENODEV;
1028 }
1029
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001030 StatusInternal currentStatus = cameraState->getStatus();
1031 if (currentStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001032 ALOGE("CameraService::connect X (PID %d) rejected (camera %s is not connected)",
1033 callingPid, cameraId.string());
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001034 return -ENODEV;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001035 } else if (currentStatus == StatusInternal::ENUMERATING) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001036 ALOGE("CameraService::connect X (PID %d) rejected, (camera %s is initializing)",
1037 callingPid, cameraId.string());
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001038 return -EBUSY;
Igor Murashkincba2c162013-03-20 15:56:31 -07001039 }
Igor Murashkincba2c162013-03-20 15:56:31 -07001040
Ruben Brunkcc776712015-02-17 20:18:47 -08001041 return NO_ERROR;
Igor Murashkine6800ce2013-03-04 17:25:57 -08001042}
1043
Ruben Brunkcc776712015-02-17 20:18:47 -08001044void CameraService::finishConnectLocked(const sp<BasicClient>& client,
1045 const CameraService::DescriptorPtr& desc) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001046
Ruben Brunkcc776712015-02-17 20:18:47 -08001047 // Make a descriptor for the incoming client
1048 auto clientDescriptor = CameraService::CameraClientManager::makeClientDescriptor(client, desc);
1049 auto evicted = mActiveClientManager.addAndEvict(clientDescriptor);
1050
1051 logConnected(desc->getKey(), static_cast<int>(desc->getOwnerId()),
1052 String8(client->getPackageName()));
1053
1054 if (evicted.size() > 0) {
1055 // This should never happen - clients should already have been removed in disconnect
1056 for (auto& i : evicted) {
1057 ALOGE("%s: Invalid state: Client for camera %s was not removed in disconnect",
1058 __FUNCTION__, i->getKey().string());
1059 }
1060
1061 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, clients not evicted properly",
1062 __FUNCTION__);
1063 }
Eino-Ville Talvala24901c82015-09-04 14:15:58 -07001064
1065 // And register a death notification for the client callback. Do
1066 // this last to avoid Binder policy where a nested Binder
1067 // transaction might be pre-empted to service the client death
1068 // notification if the client process dies before linkToDeath is
1069 // invoked.
1070 sp<IBinder> remoteCallback = client->getRemote();
1071 if (remoteCallback != nullptr) {
1072 remoteCallback->linkToDeath(this);
1073 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001074}
1075
1076status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clientPid,
1077 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
1078 /*out*/
1079 sp<BasicClient>* client,
1080 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001081 ATRACE_CALL();
Ruben Brunkcc776712015-02-17 20:18:47 -08001082 status_t ret = NO_ERROR;
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001083 std::vector<DescriptorPtr> evictedClients;
Ruben Brunkcc776712015-02-17 20:18:47 -08001084 DescriptorPtr clientDescriptor;
1085 {
1086 if (effectiveApiLevel == API_1) {
1087 // If we are using API1, any existing client for this camera ID with the same remote
1088 // should be returned rather than evicted to allow MediaRecorder to work properly.
1089
1090 auto current = mActiveClientManager.get(cameraId);
1091 if (current != nullptr) {
1092 auto clientSp = current->getValue();
1093 if (clientSp.get() != nullptr) { // should never be needed
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07001094 if (!clientSp->canCastToApiClient(effectiveApiLevel)) {
1095 ALOGW("CameraService connect called from same client, but with a different"
1096 " API level, evicting prior client...");
1097 } else if (clientSp->getRemote() == remoteCallback) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001098 ALOGI("CameraService::connect X (PID %d) (second call from same"
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07001099 " app binder, returning the same client)", clientPid);
Ruben Brunkcc776712015-02-17 20:18:47 -08001100 *client = clientSp;
1101 return NO_ERROR;
1102 }
1103 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001104 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001105 }
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +08001106
Ruben Brunkcc776712015-02-17 20:18:47 -08001107 // Get current active client PIDs
1108 std::vector<int> ownerPids(mActiveClientManager.getAllOwners());
1109 ownerPids.push_back(clientPid);
Igor Murashkine6800ce2013-03-04 17:25:57 -08001110
Emilian Peev8131a262017-02-01 12:33:43 +00001111 std::vector<int> priorityScores(ownerPids.size());
1112 std::vector<int> states(ownerPids.size());
Igor Murashkine6800ce2013-03-04 17:25:57 -08001113
Emilian Peev8131a262017-02-01 12:33:43 +00001114 // Get priority scores of all active PIDs
1115 status_t err = ProcessInfoService::getProcessStatesScoresFromPids(
1116 ownerPids.size(), &ownerPids[0], /*out*/&states[0],
1117 /*out*/&priorityScores[0]);
1118 if (err != OK) {
1119 ALOGE("%s: Priority score query failed: %d",
1120 __FUNCTION__, err);
1121 return err;
1122 }
Ruben Brunkb2119af2014-05-09 19:57:56 -07001123
Ruben Brunkcc776712015-02-17 20:18:47 -08001124 // Update all active clients' priorities
Emilian Peev8131a262017-02-01 12:33:43 +00001125 std::map<int,resource_policy::ClientPriority> pidToPriorityMap;
Ruben Brunkcc776712015-02-17 20:18:47 -08001126 for (size_t i = 0; i < ownerPids.size() - 1; i++) {
Emilian Peev8131a262017-02-01 12:33:43 +00001127 pidToPriorityMap.emplace(ownerPids[i],
Jayant Chowdharyc578a502019-05-08 10:57:54 -07001128 resource_policy::ClientPriority(priorityScores[i], states[i],
1129 /* isVendorClient won't get copied over*/ false));
Ruben Brunkcc776712015-02-17 20:18:47 -08001130 }
1131 mActiveClientManager.updatePriorities(pidToPriorityMap);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001132
Ruben Brunkcc776712015-02-17 20:18:47 -08001133 // Get state for the given cameraId
1134 auto state = getCameraState(cameraId);
1135 if (state == nullptr) {
1136 ALOGE("CameraService::connect X (PID %d) rejected (no camera device with ID %s)",
1137 clientPid, cameraId.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001138 // Should never get here because validateConnectLocked should have errored out
Zhijun Heb10cdad2014-06-16 16:38:35 -07001139 return BAD_VALUE;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001140 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001141
1142 // Make descriptor for incoming client
Shuzhen Wang2db86ff2018-04-25 01:11:17 +00001143 clientDescriptor = CameraClientManager::makeClientDescriptor(cameraId,
Ruben Brunkcc776712015-02-17 20:18:47 -08001144 sp<BasicClient>{nullptr}, static_cast<int32_t>(state->getCost()),
1145 state->getConflicting(),
Emilian Peev8131a262017-02-01 12:33:43 +00001146 priorityScores[priorityScores.size() - 1],
1147 clientPid,
1148 states[states.size() - 1]);
Ruben Brunkcc776712015-02-17 20:18:47 -08001149
1150 // Find clients that would be evicted
1151 auto evicted = mActiveClientManager.wouldEvict(clientDescriptor);
1152
1153 // If the incoming client was 'evicted,' higher priority clients have the camera in the
1154 // background, so we cannot do evictions
1155 if (std::find(evicted.begin(), evicted.end(), clientDescriptor) != evicted.end()) {
1156 ALOGE("CameraService::connect X (PID %d) rejected (existing client(s) with higher"
1157 " priority).", clientPid);
1158
1159 sp<BasicClient> clientSp = clientDescriptor->getValue();
1160 String8 curTime = getFormattedCurrentTime();
1161 auto incompatibleClients =
1162 mActiveClientManager.getIncompatibleClients(clientDescriptor);
1163
1164 String8 msg = String8::format("%s : DENIED connect device %s client for package %s "
Emilian Peev8131a262017-02-01 12:33:43 +00001165 "(PID %d, score %d state %d) due to eviction policy", curTime.string(),
Ruben Brunkcc776712015-02-17 20:18:47 -08001166 cameraId.string(), packageName.string(), clientPid,
Emilian Peev8131a262017-02-01 12:33:43 +00001167 priorityScores[priorityScores.size() - 1],
1168 states[states.size() - 1]);
Ruben Brunkcc776712015-02-17 20:18:47 -08001169
1170 for (auto& i : incompatibleClients) {
1171 msg.appendFormat("\n - Blocked by existing device %s client for package %s"
Emilian Peev8131a262017-02-01 12:33:43 +00001172 "(PID %" PRId32 ", score %" PRId32 ", state %" PRId32 ")",
1173 i->getKey().string(),
1174 String8{i->getValue()->getPackageName()}.string(),
1175 i->getOwnerId(), i->getPriority().getScore(),
1176 i->getPriority().getState());
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07001177 ALOGE(" Conflicts with: Device %s, client package %s (PID %"
Emilian Peev8131a262017-02-01 12:33:43 +00001178 PRId32 ", score %" PRId32 ", state %" PRId32 ")", i->getKey().string(),
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07001179 String8{i->getValue()->getPackageName()}.string(), i->getOwnerId(),
Emilian Peev8131a262017-02-01 12:33:43 +00001180 i->getPriority().getScore(), i->getPriority().getState());
Ruben Brunkcc776712015-02-17 20:18:47 -08001181 }
1182
1183 // Log the client's attempt
Ruben Brunka8ca9152015-04-07 14:23:40 -07001184 Mutex::Autolock l(mLogLock);
Ruben Brunkcc776712015-02-17 20:18:47 -08001185 mEventLog.add(msg);
1186
1187 return -EBUSY;
1188 }
1189
1190 for (auto& i : evicted) {
1191 sp<BasicClient> clientSp = i->getValue();
1192 if (clientSp.get() == nullptr) {
1193 ALOGE("%s: Invalid state: Null client in active client list.", __FUNCTION__);
1194
1195 // TODO: Remove this
1196 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, null client in active list",
1197 __FUNCTION__);
1198 mActiveClientManager.remove(i);
1199 continue;
1200 }
1201
1202 ALOGE("CameraService::connect evicting conflicting client for camera ID %s",
1203 i->getKey().string());
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001204 evictedClients.push_back(i);
Ruben Brunkcc776712015-02-17 20:18:47 -08001205
Ruben Brunkcc776712015-02-17 20:18:47 -08001206 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07001207 logEvent(String8::format("EVICT device %s client held by package %s (PID"
Emilian Peev8131a262017-02-01 12:33:43 +00001208 " %" PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted by device %s client for"
1209 " package %s (PID %d, score %" PRId32 ", state %" PRId32 ")",
Ruben Brunkcc776712015-02-17 20:18:47 -08001210 i->getKey().string(), String8{clientSp->getPackageName()}.string(),
Emilian Peev8131a262017-02-01 12:33:43 +00001211 i->getOwnerId(), i->getPriority().getScore(),
1212 i->getPriority().getState(), cameraId.string(),
Ruben Brunkcc776712015-02-17 20:18:47 -08001213 packageName.string(), clientPid,
Emilian Peev8131a262017-02-01 12:33:43 +00001214 priorityScores[priorityScores.size() - 1],
1215 states[states.size() - 1]));
Ruben Brunkcc776712015-02-17 20:18:47 -08001216
1217 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001218 clientSp->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -08001219 CaptureResultExtras());
Zhijun Heb10cdad2014-06-16 16:38:35 -07001220 }
Ruben Brunkb2119af2014-05-09 19:57:56 -07001221 }
1222
Ruben Brunkcc776712015-02-17 20:18:47 -08001223 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1224 // other clients from connecting in mServiceLockWrapper if held
1225 mServiceLock.unlock();
1226
1227 // Clear caller identity temporarily so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -07001228 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunkcc776712015-02-17 20:18:47 -08001229
1230 // Destroy evicted clients
1231 for (auto& i : evictedClients) {
1232 // Disconnect is blocking, and should only have returned when HAL has cleaned up
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001233 i->getValue()->disconnect(); // Clients will remove themselves from the active client list
Ruben Brunkcc776712015-02-17 20:18:47 -08001234 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001235
Jayant Chowdhary12361932018-08-27 14:46:13 -07001236 CameraThreadState::restoreCallingIdentity(token);
Ruben Brunkcc776712015-02-17 20:18:47 -08001237
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001238 for (const auto& i : evictedClients) {
1239 ALOGV("%s: Waiting for disconnect to complete for client for device %s (PID %" PRId32 ")",
1240 __FUNCTION__, i->getKey().string(), i->getOwnerId());
1241 ret = mActiveClientManager.waitUntilRemoved(i, DEFAULT_DISCONNECT_TIMEOUT_NS);
1242 if (ret == TIMED_OUT) {
1243 ALOGE("%s: Timed out waiting for client for device %s to disconnect, "
1244 "current clients:\n%s", __FUNCTION__, i->getKey().string(),
1245 mActiveClientManager.toString().string());
1246 return -EBUSY;
1247 }
1248 if (ret != NO_ERROR) {
1249 ALOGE("%s: Received error waiting for client for device %s to disconnect: %s (%d), "
1250 "current clients:\n%s", __FUNCTION__, i->getKey().string(), strerror(-ret),
1251 ret, mActiveClientManager.toString().string());
1252 return ret;
1253 }
1254 }
1255
1256 evictedClients.clear();
1257
Ruben Brunkcc776712015-02-17 20:18:47 -08001258 // Once clients have been disconnected, relock
1259 mServiceLock.lock();
1260
1261 // Check again if the device was unplugged or something while we weren't holding mServiceLock
1262 if ((ret = checkIfDeviceIsUsable(cameraId)) != NO_ERROR) {
1263 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -07001264 }
1265
Ruben Brunkcc776712015-02-17 20:18:47 -08001266 *partial = clientDescriptor;
1267 return NO_ERROR;
Ruben Brunkb2119af2014-05-09 19:57:56 -07001268}
1269
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001270Status CameraService::connect(
Igor Murashkine6800ce2013-03-04 17:25:57 -08001271 const sp<ICameraClient>& cameraClient,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001272 int api1CameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001273 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001274 int clientUid,
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001275 int clientPid,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001276 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001277 sp<ICamera>* device) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001278
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001279 ATRACE_CALL();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001280 Status ret = Status::ok();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001281
1282 String8 id = cameraIdIntToStr(api1CameraId);
Ruben Brunkcc776712015-02-17 20:18:47 -08001283 sp<Client> client = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001284 ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001285 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001286 /*shimUpdateOnly*/ false, /*out*/client);
Igor Murashkine6800ce2013-03-04 17:25:57 -08001287
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001288 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001289 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001290 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001291 return ret;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001292 }
1293
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001294 *device = client;
1295 return ret;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001296}
1297
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001298Status CameraService::connectLegacy(
Zhijun Heb10cdad2014-06-16 16:38:35 -07001299 const sp<ICameraClient>& cameraClient,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001300 int api1CameraId, int halVersion,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001301 const String16& clientPackageName,
Zhijun Heb10cdad2014-06-16 16:38:35 -07001302 int clientUid,
1303 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001304 sp<ICamera>* device) {
Zhijun Heb10cdad2014-06-16 16:38:35 -07001305
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001306 ATRACE_CALL();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001307 String8 id = cameraIdIntToStr(api1CameraId);
Zhijun Heb10cdad2014-06-16 16:38:35 -07001308
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001309 Status ret = Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001310 sp<Client> client = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001311 ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId, halVersion,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001312 clientPackageName, clientUid, USE_CALLING_PID, API_1, /*shimUpdateOnly*/ false,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001313 /*out*/client);
Zhijun Heb10cdad2014-06-16 16:38:35 -07001314
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001315 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001316 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001317 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001318 return ret;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001319 }
1320
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001321 *device = client;
1322 return ret;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001323}
1324
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001325bool CameraService::shouldRejectHiddenCameraConnection(const String8 & cameraId) {
1326 // If the thread serving this call is not a hwbinder thread and the caller
1327 // isn't the cameraserver itself, and the camera id being requested is to be
1328 // publically hidden, we should reject the connection.
1329 if (!hardware::IPCThreadState::self()->isServingCall() &&
1330 CameraThreadState::getCallingPid() != getpid() &&
1331 mCameraProviderManager->isPublicallyHiddenSecureCamera(cameraId.c_str())) {
1332 return true;
1333 }
1334 return false;
1335}
1336
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001337Status CameraService::connectDevice(
1338 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001339 const String16& cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001340 const String16& clientPackageName,
Ruben Brunkcc776712015-02-17 20:18:47 -08001341 int clientUid,
1342 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001343 sp<hardware::camera2::ICameraDeviceUser>* device) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001344
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001345 ATRACE_CALL();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001346 Status ret = Status::ok();
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001347 String8 id = String8(cameraId);
Ruben Brunkcc776712015-02-17 20:18:47 -08001348 sp<CameraDeviceClient> client = nullptr;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001349
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001350 ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001351 /*api1CameraId*/-1,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001352 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001353 clientUid, USE_CALLING_PID, API_2, /*shimUpdateOnly*/ false, /*out*/client);
Ruben Brunkcc776712015-02-17 20:18:47 -08001354
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001355 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001356 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001357 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001358 return ret;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001359 }
1360
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001361 *device = client;
1362 return ret;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001363}
1364
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001365template<class CALLBACK, class CLIENT>
1366Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001367 int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001368 int clientPid, apiLevel effectiveApiLevel, bool shimUpdateOnly,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001369 /*out*/sp<CLIENT>& device) {
1370 binder::Status ret = binder::Status::ok();
1371
1372 String8 clientName8(clientPackageName);
1373
1374 int originalClientPid = 0;
1375
1376 ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
1377 "Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
1378 (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
1379 static_cast<int>(effectiveApiLevel));
1380
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001381 if (shouldRejectHiddenCameraConnection(cameraId)) {
1382 ALOGW("Attempting to connect to system-only camera id %s, connection rejected",
1383 cameraId.c_str());
1384 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1385 "No camera device with ID \"%s\" currently available",
1386 cameraId.string());
1387
1388 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001389 sp<CLIENT> client = nullptr;
1390 {
1391 // Acquire mServiceLock and prevent other clients from connecting
1392 std::unique_ptr<AutoConditionLock> lock =
1393 AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
1394
1395 if (lock == nullptr) {
1396 ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
1397 , clientPid);
1398 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1399 "Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
1400 cameraId.string(), clientName8.string(), clientPid);
1401 }
1402
1403 // Enforce client permissions and do basic sanity checks
1404 if(!(ret = validateConnectLocked(cameraId, clientName8,
1405 /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
1406 return ret;
1407 }
1408
1409 // Check the shim parameters after acquiring lock, if they have already been updated and
1410 // we were doing a shim update, return immediately
1411 if (shimUpdateOnly) {
1412 auto cameraState = getCameraState(cameraId);
1413 if (cameraState != nullptr) {
1414 if (!cameraState->getShimParams().isEmpty()) return ret;
1415 }
1416 }
1417
1418 status_t err;
1419
1420 sp<BasicClient> clientTmp = nullptr;
1421 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
1422 if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
1423 IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
1424 /*out*/&partial)) != NO_ERROR) {
1425 switch (err) {
1426 case -ENODEV:
1427 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1428 "No camera device with ID \"%s\" currently available",
1429 cameraId.string());
1430 case -EBUSY:
1431 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1432 "Higher-priority client using camera, ID \"%s\" currently unavailable",
1433 cameraId.string());
1434 default:
1435 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1436 "Unexpected error %s (%d) opening camera \"%s\"",
1437 strerror(-err), err, cameraId.string());
1438 }
1439 }
1440
1441 if (clientTmp.get() != nullptr) {
1442 // Handle special case for API1 MediaRecorder where the existing client is returned
1443 device = static_cast<CLIENT*>(clientTmp.get());
1444 return ret;
1445 }
1446
1447 // give flashlight a chance to close devices if necessary.
1448 mFlashlight->prepareDeviceOpen(cameraId);
1449
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001450 int facing = -1;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001451 int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
Eino-Ville Talvala6963d0a2017-01-31 13:00:34 -08001452 if (facing == -1) {
1453 ALOGE("%s: Unable to get camera device \"%s\" facing", __FUNCTION__, cameraId.string());
1454 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1455 "Unable to get camera device \"%s\" facing", cameraId.string());
1456 }
1457
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001458 sp<BasicClient> tmp = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001459 if(!(ret = makeClient(this, cameraCb, clientPackageName,
1460 cameraId, api1CameraId, facing,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001461 clientPid, clientUid, getpid(),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001462 halVersion, deviceVersion, effectiveApiLevel,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001463 /*out*/&tmp)).isOk()) {
1464 return ret;
1465 }
1466 client = static_cast<CLIENT*>(tmp.get());
1467
1468 LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
1469 __FUNCTION__);
1470
Emilian Peevbd8c5032018-02-14 23:05:40 +00001471 err = client->initialize(mCameraProviderManager, mMonitorTags);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001472 if (err != OK) {
1473 ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001474 // Errors could be from the HAL module open call or from AppOpsManager
1475 switch(err) {
1476 case BAD_VALUE:
1477 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1478 "Illegal argument to HAL module for camera \"%s\"", cameraId.string());
1479 case -EBUSY:
1480 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1481 "Camera \"%s\" is already open", cameraId.string());
1482 case -EUSERS:
1483 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1484 "Too many cameras already open, cannot open camera \"%s\"",
1485 cameraId.string());
1486 case PERMISSION_DENIED:
1487 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1488 "No permission to open camera \"%s\"", cameraId.string());
1489 case -EACCES:
1490 return STATUS_ERROR_FMT(ERROR_DISABLED,
1491 "Camera \"%s\" disabled by policy", cameraId.string());
1492 case -ENODEV:
1493 default:
1494 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1495 "Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
1496 strerror(-err), err);
1497 }
1498 }
1499
1500 // Update shim paremeters for legacy clients
1501 if (effectiveApiLevel == API_1) {
1502 // Assume we have always received a Client subclass for API1
1503 sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
1504 String8 rawParams = shimClient->getParameters();
1505 CameraParameters params(rawParams);
1506
1507 auto cameraState = getCameraState(cameraId);
1508 if (cameraState != nullptr) {
1509 cameraState->setShimParams(params);
1510 } else {
1511 ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
1512 __FUNCTION__, cameraId.string());
1513 }
1514 }
1515
1516 if (shimUpdateOnly) {
1517 // If only updating legacy shim parameters, immediately disconnect client
1518 mServiceLock.unlock();
1519 client->disconnect();
1520 mServiceLock.lock();
1521 } else {
1522 // Otherwise, add client to active clients list
1523 finishConnectLocked(client, partial);
1524 }
1525 } // lock is destroyed, allow further connect calls
1526
1527 // Important: release the mutex here so the client can call back into the service from its
1528 // destructor (can be at the end of the call)
1529 device = client;
1530 return ret;
1531}
1532
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001533Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001534 const sp<IBinder>& clientBinder) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001535 Mutex::Autolock lock(mServiceLock);
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001536
1537 ATRACE_CALL();
Ruben Brunk99e69712015-05-26 17:25:07 -07001538 if (enabled && clientBinder == nullptr) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001539 ALOGE("%s: torch client binder is NULL", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001540 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
1541 "Torch client Binder is null");
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001542 }
1543
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001544 String8 id = String8(cameraId.string());
Jayant Chowdhary12361932018-08-27 14:46:13 -07001545 int uid = CameraThreadState::getCallingUid();
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001546
1547 // verify id is valid.
Ruben Brunkcc776712015-02-17 20:18:47 -08001548 auto state = getCameraState(id);
1549 if (state == nullptr) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07001550 ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001551 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1552 "Camera ID \"%s\" is a not valid camera ID", id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -08001553 }
1554
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001555 StatusInternal cameraStatus = state->getStatus();
1556 if (cameraStatus != StatusInternal::PRESENT &&
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001557 cameraStatus != StatusInternal::NOT_AVAILABLE) {
1558 ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001559 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1560 "Camera ID \"%s\" is a not valid camera ID", id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001561 }
1562
1563 {
1564 Mutex::Autolock al(mTorchStatusMutex);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001565 TorchModeStatus status;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001566 status_t err = getTorchStatusLocked(id, &status);
1567 if (err != OK) {
1568 if (err == NAME_NOT_FOUND) {
1569 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1570 "Camera \"%s\" does not have a flash unit", id.string());
1571 }
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001572 ALOGE("%s: getting current torch status failed for camera %s",
1573 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001574 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1575 "Error updating torch status for camera \"%s\": %s (%d)", id.string(),
1576 strerror(-err), err);
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001577 }
1578
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001579 if (status == TorchModeStatus::NOT_AVAILABLE) {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001580 if (cameraStatus == StatusInternal::NOT_AVAILABLE) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001581 ALOGE("%s: torch mode of camera %s is not available because "
1582 "camera is in use", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001583 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1584 "Torch for camera \"%s\" is not available due to an existing camera user",
1585 id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001586 } else {
1587 ALOGE("%s: torch mode of camera %s is not available due to "
1588 "insufficient resources", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001589 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1590 "Torch for camera \"%s\" is not available due to insufficient resources",
1591 id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001592 }
1593 }
1594 }
1595
Ruben Brunk99e69712015-05-26 17:25:07 -07001596 {
1597 // Update UID map - this is used in the torch status changed callbacks, so must be done
1598 // before setTorchMode
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001599 Mutex::Autolock al(mTorchUidMapMutex);
Ruben Brunk99e69712015-05-26 17:25:07 -07001600 if (mTorchUidMap.find(id) == mTorchUidMap.end()) {
1601 mTorchUidMap[id].first = uid;
1602 mTorchUidMap[id].second = uid;
1603 } else {
1604 // Set the pending UID
1605 mTorchUidMap[id].first = uid;
1606 }
1607 }
1608
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001609 status_t err = mFlashlight->setTorchMode(id, enabled);
Ruben Brunk99e69712015-05-26 17:25:07 -07001610
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001611 if (err != OK) {
1612 int32_t errorCode;
1613 String8 msg;
1614 switch (err) {
1615 case -ENOSYS:
1616 msg = String8::format("Camera \"%s\" has no flashlight",
1617 id.string());
1618 errorCode = ERROR_ILLEGAL_ARGUMENT;
1619 break;
1620 default:
1621 msg = String8::format(
1622 "Setting torch mode of camera \"%s\" to %d failed: %s (%d)",
1623 id.string(), enabled, strerror(-err), err);
1624 errorCode = ERROR_INVALID_OPERATION;
1625 }
1626 ALOGE("%s: %s", __FUNCTION__, msg.string());
1627 return STATUS_ERROR(errorCode, msg.string());
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001628 }
1629
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001630 {
1631 // update the link to client's death
1632 Mutex::Autolock al(mTorchClientMapMutex);
1633 ssize_t index = mTorchClientMap.indexOfKey(id);
1634 if (enabled) {
1635 if (index == NAME_NOT_FOUND) {
1636 mTorchClientMap.add(id, clientBinder);
1637 } else {
Ruben Brunk99e69712015-05-26 17:25:07 -07001638 mTorchClientMap.valueAt(index)->unlinkToDeath(this);
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001639 mTorchClientMap.replaceValueAt(index, clientBinder);
1640 }
1641 clientBinder->linkToDeath(this);
1642 } else if (index != NAME_NOT_FOUND) {
Ruben Brunk99e69712015-05-26 17:25:07 -07001643 mTorchClientMap.valueAt(index)->unlinkToDeath(this);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001644 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001645 }
1646
Jayant Chowdhary0e2eefd2019-04-18 14:05:43 -07001647 int clientPid = CameraThreadState::getCallingPid();
1648 const char *id_cstr = id.c_str();
1649 const char *torchState = enabled ? "on" : "off";
1650 ALOGI("Torch for camera id %s turned %s for client PID %d", id_cstr, torchState, clientPid);
1651 logTorchEvent(id_cstr, torchState , clientPid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001652 return Status::ok();
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001653}
1654
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001655Status CameraService::notifySystemEvent(int32_t eventId,
1656 const std::vector<int32_t>& args) {
Jeongik Chaaa5e64c2018-11-17 05:08:04 +09001657 const int pid = CameraThreadState::getCallingPid();
1658 const int selfPid = getpid();
1659
1660 // Permission checks
1661 if (pid != selfPid) {
1662 // Ensure we're being called by system_server, or similar process with
1663 // permissions to notify the camera service about system events
1664 if (!checkCallingPermission(
1665 String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) {
1666 const int uid = CameraThreadState::getCallingUid();
1667 ALOGE("Permission Denial: cannot send updates to camera service about system"
1668 " events from pid=%d, uid=%d", pid, uid);
1669 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
Jeongik Chaaa1b8152018-11-21 10:02:25 +09001670 "No permission to send updates to camera service about system events"
1671 " from pid=%d, uid=%d", pid, uid);
Jeongik Chaaa5e64c2018-11-17 05:08:04 +09001672 }
1673 }
1674
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001675 ATRACE_CALL();
1676
Ruben Brunk36597b22015-03-20 22:15:57 -07001677 switch(eventId) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001678 case ICameraService::EVENT_USER_SWITCHED: {
Michael Grooverd1d435a2018-12-18 17:39:42 -08001679 // Try to register for UID and sensor privacy policy updates, in case we're recovering
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07001680 // from a system server crash
1681 mUidPolicy->registerSelf();
Michael Grooverd1d435a2018-12-18 17:39:42 -08001682 mSensorPrivacyPolicy->registerSelf();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001683 doUserSwitch(/*newUserIds*/ args);
Ruben Brunk36597b22015-03-20 22:15:57 -07001684 break;
1685 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001686 case ICameraService::EVENT_NONE:
Ruben Brunk36597b22015-03-20 22:15:57 -07001687 default: {
1688 ALOGW("%s: Received invalid system event from system_server: %d", __FUNCTION__,
1689 eventId);
1690 break;
1691 }
1692 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001693 return Status::ok();
Ruben Brunk36597b22015-03-20 22:15:57 -07001694}
1695
Emilian Peev53722fa2019-02-22 17:47:20 -08001696void CameraService::notifyMonitoredUids() {
1697 Mutex::Autolock lock(mStatusListenerLock);
1698
1699 for (const auto& it : mListenerList) {
1700 auto ret = it.second->getListener()->onCameraAccessPrioritiesChanged();
1701 if (!ret.isOk()) {
1702 ALOGE("%s: Failed to trigger permission callback: %d", __FUNCTION__,
1703 ret.exceptionCode());
1704 }
1705 }
1706}
1707
Eino-Ville Talvala63f36112018-12-06 14:57:03 -08001708Status CameraService::notifyDeviceStateChange(int64_t newState) {
1709 const int pid = CameraThreadState::getCallingPid();
1710 const int selfPid = getpid();
1711
1712 // Permission checks
1713 if (pid != selfPid) {
1714 // Ensure we're being called by system_server, or similar process with
1715 // permissions to notify the camera service about system events
1716 if (!checkCallingPermission(
1717 String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) {
1718 const int uid = CameraThreadState::getCallingUid();
1719 ALOGE("Permission Denial: cannot send updates to camera service about device"
1720 " state changes from pid=%d, uid=%d", pid, uid);
1721 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1722 "No permission to send updates to camera service about device state"
1723 " changes from pid=%d, uid=%d", pid, uid);
1724 }
1725 }
1726
1727 ATRACE_CALL();
1728
1729 using hardware::camera::provider::V2_5::DeviceState;
1730 hardware::hidl_bitfield<DeviceState> newDeviceState{};
1731 if (newState & ICameraService::DEVICE_STATE_BACK_COVERED) {
1732 newDeviceState |= DeviceState::BACK_COVERED;
1733 }
1734 if (newState & ICameraService::DEVICE_STATE_FRONT_COVERED) {
1735 newDeviceState |= DeviceState::FRONT_COVERED;
1736 }
1737 if (newState & ICameraService::DEVICE_STATE_FOLDED) {
1738 newDeviceState |= DeviceState::FOLDED;
1739 }
1740 // Only map vendor bits directly
1741 uint64_t vendorBits = static_cast<uint64_t>(newState) & 0xFFFFFFFF00000000l;
1742 newDeviceState |= vendorBits;
1743
1744 ALOGV("%s: New device state 0x%" PRIx64, __FUNCTION__, newDeviceState);
1745 Mutex::Autolock l(mServiceLock);
1746 mCameraProviderManager->notifyDeviceStateChange(newDeviceState);
1747
1748 return Status::ok();
1749}
1750
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001751Status CameraService::addListener(const sp<ICameraServiceListener>& listener,
1752 /*out*/
1753 std::vector<hardware::CameraStatus> *cameraStatuses) {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001754 return addListenerHelper(listener, cameraStatuses);
1755}
1756
1757Status CameraService::addListenerHelper(const sp<ICameraServiceListener>& listener,
1758 /*out*/
1759 std::vector<hardware::CameraStatus> *cameraStatuses,
1760 bool isVendorListener) {
1761
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001762 ATRACE_CALL();
1763
Igor Murashkinbfc99152013-02-27 12:55:20 -08001764 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
Igor Murashkin634a5152013-02-20 17:15:11 -08001765
Ruben Brunk3450ba72015-06-16 11:00:37 -07001766 if (listener == nullptr) {
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001767 ALOGE("%s: Listener must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001768 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to addListener");
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001769 }
1770
Igor Murashkinbfc99152013-02-27 12:55:20 -08001771 Mutex::Autolock lock(mServiceLock);
1772
Ruben Brunkcc776712015-02-17 20:18:47 -08001773 {
1774 Mutex::Autolock lock(mStatusListenerLock);
Emilian Peev53722fa2019-02-22 17:47:20 -08001775 for (const auto &it : mListenerList) {
1776 if (IInterface::asBinder(it.second->getListener()) == IInterface::asBinder(listener)) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001777 ALOGW("%s: Tried to add listener %p which was already subscribed",
1778 __FUNCTION__, listener.get());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001779 return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
Ruben Brunkcc776712015-02-17 20:18:47 -08001780 }
Igor Murashkinbfc99152013-02-27 12:55:20 -08001781 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001782
Emilian Peev53722fa2019-02-22 17:47:20 -08001783 auto clientUid = CameraThreadState::getCallingUid();
1784 sp<ServiceListener> serviceListener = new ServiceListener(this, listener, clientUid);
1785 auto ret = serviceListener->initialize();
1786 if (ret != NO_ERROR) {
1787 String8 msg = String8::format("Failed to initialize service listener: %s (%d)",
1788 strerror(-ret), ret);
1789 ALOGE("%s: %s", __FUNCTION__, msg.string());
1790 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
1791 }
1792 mListenerList.emplace_back(isVendorListener, serviceListener);
1793 mUidPolicy->registerMonitorUid(clientUid);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001794 }
1795
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001796 /* Collect current devices and status */
Igor Murashkincba2c162013-03-20 15:56:31 -07001797 {
Ruben Brunkcc776712015-02-17 20:18:47 -08001798 Mutex::Autolock lock(mCameraStatesLock);
1799 for (auto& i : mCameraStates) {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001800 if (!isVendorListener &&
1801 mCameraProviderManager->isPublicallyHiddenSecureCamera(i.first.c_str())) {
1802 ALOGV("Cannot add public listener for hidden system-only %s for pid %d",
1803 i.first.c_str(), CameraThreadState::getCallingPid());
1804 continue;
1805 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001806 cameraStatuses->emplace_back(i.first, mapToInterface(i.second->getStatus()));
Igor Murashkincba2c162013-03-20 15:56:31 -07001807 }
1808 }
1809
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001810 /*
1811 * Immediately signal current torch status to this listener only
1812 * This may be a subset of all the devices, so don't include it in the response directly
1813 */
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001814 {
1815 Mutex::Autolock al(mTorchStatusMutex);
1816 for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001817 String16 id = String16(mTorchStatusMap.keyAt(i).string());
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001818 listener->onTorchStatusChanged(mapToInterface(mTorchStatusMap.valueAt(i)), id);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001819 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001820 }
1821
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001822 return Status::ok();
Igor Murashkinbfc99152013-02-27 12:55:20 -08001823}
Ruben Brunkcc776712015-02-17 20:18:47 -08001824
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001825Status CameraService::removeListener(const sp<ICameraServiceListener>& listener) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001826 ATRACE_CALL();
1827
Igor Murashkinbfc99152013-02-27 12:55:20 -08001828 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
1829
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001830 if (listener == 0) {
1831 ALOGE("%s: Listener must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001832 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to removeListener");
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001833 }
1834
Igor Murashkinbfc99152013-02-27 12:55:20 -08001835 Mutex::Autolock lock(mServiceLock);
1836
Ruben Brunkcc776712015-02-17 20:18:47 -08001837 {
1838 Mutex::Autolock lock(mStatusListenerLock);
1839 for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) {
Emilian Peev53722fa2019-02-22 17:47:20 -08001840 if (IInterface::asBinder(it->second->getListener()) == IInterface::asBinder(listener)) {
1841 mUidPolicy->unregisterMonitorUid(it->second->getListenerUid());
1842 IInterface::asBinder(listener)->unlinkToDeath(it->second);
Ruben Brunkcc776712015-02-17 20:18:47 -08001843 mListenerList.erase(it);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001844 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001845 }
Igor Murashkinbfc99152013-02-27 12:55:20 -08001846 }
1847 }
1848
1849 ALOGW("%s: Tried to remove a listener %p which was not subscribed",
1850 __FUNCTION__, listener.get());
1851
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001852 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Unregistered listener given to removeListener");
Igor Murashkin634a5152013-02-20 17:15:11 -08001853}
1854
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001855Status CameraService::getLegacyParameters(int cameraId, /*out*/String16* parameters) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001856
1857 ATRACE_CALL();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001858 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1859
1860 if (parameters == NULL) {
1861 ALOGE("%s: parameters must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001862 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
Igor Murashkin65d14b92014-06-17 12:03:20 -07001863 }
1864
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001865 Status ret = Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001866
1867 CameraParameters shimParams;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001868 if (!(ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)).isOk()) {
Igor Murashkin65d14b92014-06-17 12:03:20 -07001869 // Error logged by caller
1870 return ret;
1871 }
1872
1873 String8 shimParamsString8 = shimParams.flatten();
1874 String16 shimParamsString16 = String16(shimParamsString8);
1875
1876 *parameters = shimParamsString16;
1877
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001878 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -07001879}
1880
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001881Status CameraService::supportsCameraApi(const String16& cameraId, int apiVersion,
1882 /*out*/ bool *isSupported) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001883 ATRACE_CALL();
1884
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001885 const String8 id = String8(cameraId);
1886
1887 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001888
1889 switch (apiVersion) {
1890 case API_VERSION_1:
1891 case API_VERSION_2:
1892 break;
1893 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001894 String8 msg = String8::format("Unknown API version %d", apiVersion);
1895 ALOGE("%s: %s", __FUNCTION__, msg.string());
1896 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001897 }
1898
Emilian Peev28ad2ea2017-02-07 16:14:32 +00001899 int deviceVersion = getDeviceVersion(id);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001900 switch (deviceVersion) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001901 case CAMERA_DEVICE_API_VERSION_1_0:
1902 case CAMERA_DEVICE_API_VERSION_3_0:
1903 case CAMERA_DEVICE_API_VERSION_3_1:
1904 if (apiVersion == API_VERSION_2) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001905 ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim",
1906 __FUNCTION__, id.string(), deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001907 *isSupported = false;
1908 } else { // if (apiVersion == API_VERSION_1) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001909 ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported",
1910 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001911 *isSupported = true;
1912 }
1913 break;
1914 case CAMERA_DEVICE_API_VERSION_3_2:
1915 case CAMERA_DEVICE_API_VERSION_3_3:
Zhijun He4afbdec2016-05-04 15:42:51 -07001916 case CAMERA_DEVICE_API_VERSION_3_4:
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001917 case CAMERA_DEVICE_API_VERSION_3_5:
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001918 ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
1919 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001920 *isSupported = true;
1921 break;
1922 case -1: {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001923 String8 msg = String8::format("Unknown camera ID %s", id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001924 ALOGE("%s: %s", __FUNCTION__, msg.string());
1925 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001926 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001927 default: {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001928 String8 msg = String8::format("Unknown device version %x for device %s",
1929 deviceVersion, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001930 ALOGE("%s: %s", __FUNCTION__, msg.string());
1931 return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
1932 }
Igor Murashkin65d14b92014-06-17 12:03:20 -07001933 }
1934
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001935 return Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001936}
1937
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001938Status CameraService::isHiddenPhysicalCamera(const String16& cameraId,
1939 /*out*/ bool *isSupported) {
1940 ATRACE_CALL();
1941
1942 const String8 id = String8(cameraId);
1943
1944 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
1945 *isSupported = mCameraProviderManager->isHiddenPhysicalCamera(id.string());
1946
1947 return Status::ok();
1948}
1949
Ruben Brunkcc776712015-02-17 20:18:47 -08001950void CameraService::removeByClient(const BasicClient* client) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001951 Mutex::Autolock lock(mServiceLock);
Ruben Brunkcc776712015-02-17 20:18:47 -08001952 for (auto& i : mActiveClientManager.getAll()) {
1953 auto clientSp = i->getValue();
1954 if (clientSp.get() == client) {
1955 mActiveClientManager.remove(i);
Igor Murashkin634a5152013-02-20 17:15:11 -08001956 }
Igor Murashkinecf17e82012-10-02 16:05:11 -07001957 }
Igor Murashkin634a5152013-02-20 17:15:11 -08001958}
1959
Ruben Brunkcc776712015-02-17 20:18:47 -08001960bool CameraService::evictClientIdByRemote(const wp<IBinder>& remote) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001961 bool ret = false;
1962 {
1963 // Acquire mServiceLock and prevent other clients from connecting
1964 std::unique_ptr<AutoConditionLock> lock =
1965 AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
Igor Murashkin634a5152013-02-20 17:15:11 -08001966
Igor Murashkin634a5152013-02-20 17:15:11 -08001967
Ruben Brunkcc776712015-02-17 20:18:47 -08001968 std::vector<sp<BasicClient>> evicted;
1969 for (auto& i : mActiveClientManager.getAll()) {
1970 auto clientSp = i->getValue();
1971 if (clientSp.get() == nullptr) {
1972 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
1973 mActiveClientManager.remove(i);
1974 continue;
1975 }
Yin-Chia Yehdbfcb382018-02-16 11:17:36 -08001976 if (remote == clientSp->getRemote()) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001977 mActiveClientManager.remove(i);
1978 evicted.push_back(clientSp);
Igor Murashkin634a5152013-02-20 17:15:11 -08001979
Ruben Brunkcc776712015-02-17 20:18:47 -08001980 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001981 clientSp->notifyError(
1982 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -08001983 CaptureResultExtras());
Igor Murashkin634a5152013-02-20 17:15:11 -08001984 }
1985 }
1986
Ruben Brunkcc776712015-02-17 20:18:47 -08001987 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1988 // other clients from connecting in mServiceLockWrapper if held
1989 mServiceLock.unlock();
1990
Ruben Brunk36597b22015-03-20 22:15:57 -07001991 // Do not clear caller identity, remote caller should be client proccess
1992
Ruben Brunkcc776712015-02-17 20:18:47 -08001993 for (auto& i : evicted) {
1994 if (i.get() != nullptr) {
1995 i->disconnect();
1996 ret = true;
1997 }
Igor Murashkin634a5152013-02-20 17:15:11 -08001998 }
1999
Ruben Brunkcc776712015-02-17 20:18:47 -08002000 // Reacquire mServiceLock
2001 mServiceLock.lock();
Igor Murashkin634a5152013-02-20 17:15:11 -08002002
Ruben Brunkcc776712015-02-17 20:18:47 -08002003 } // lock is destroyed, allow further connect calls
2004
2005 return ret;
Igor Murashkinecf17e82012-10-02 16:05:11 -07002006}
2007
Ruben Brunkcc776712015-02-17 20:18:47 -08002008std::shared_ptr<CameraService::CameraState> CameraService::getCameraState(
2009 const String8& cameraId) const {
2010 std::shared_ptr<CameraState> state;
2011 {
2012 Mutex::Autolock lock(mCameraStatesLock);
2013 auto iter = mCameraStates.find(cameraId);
2014 if (iter != mCameraStates.end()) {
2015 state = iter->second;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002016 }
2017 }
Ruben Brunkcc776712015-02-17 20:18:47 -08002018 return state;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002019}
2020
Ruben Brunkcc776712015-02-17 20:18:47 -08002021sp<CameraService::BasicClient> CameraService::removeClientLocked(const String8& cameraId) {
2022 // Remove from active clients list
2023 auto clientDescriptorPtr = mActiveClientManager.remove(cameraId);
2024 if (clientDescriptorPtr == nullptr) {
2025 ALOGW("%s: Could not evict client, no client for camera ID %s", __FUNCTION__,
2026 cameraId.string());
2027 return sp<BasicClient>{nullptr};
2028 }
2029
2030 return clientDescriptorPtr->getValue();
Keun young Parkd8973a72012-03-28 14:13:09 -07002031}
2032
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002033void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) {
Ruben Brunk36597b22015-03-20 22:15:57 -07002034 // Acquire mServiceLock and prevent other clients from connecting
2035 std::unique_ptr<AutoConditionLock> lock =
2036 AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
2037
Ruben Brunk6267b532015-04-30 17:44:07 -07002038 std::set<userid_t> newAllowedUsers;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002039 for (size_t i = 0; i < newUserIds.size(); i++) {
2040 if (newUserIds[i] < 0) {
Ruben Brunk6267b532015-04-30 17:44:07 -07002041 ALOGE("%s: Bad user ID %d given during user switch, ignoring.",
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002042 __FUNCTION__, newUserIds[i]);
Ruben Brunk6267b532015-04-30 17:44:07 -07002043 return;
2044 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002045 newAllowedUsers.insert(static_cast<userid_t>(newUserIds[i]));
Ruben Brunk36597b22015-03-20 22:15:57 -07002046 }
2047
Ruben Brunka8ca9152015-04-07 14:23:40 -07002048
Ruben Brunk6267b532015-04-30 17:44:07 -07002049 if (newAllowedUsers == mAllowedUsers) {
2050 ALOGW("%s: Received notification of user switch with no updated user IDs.", __FUNCTION__);
2051 return;
2052 }
2053
2054 logUserSwitch(mAllowedUsers, newAllowedUsers);
2055
2056 mAllowedUsers = std::move(newAllowedUsers);
Ruben Brunk36597b22015-03-20 22:15:57 -07002057
2058 // Current user has switched, evict all current clients.
2059 std::vector<sp<BasicClient>> evicted;
2060 for (auto& i : mActiveClientManager.getAll()) {
2061 auto clientSp = i->getValue();
2062
2063 if (clientSp.get() == nullptr) {
2064 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
2065 continue;
2066 }
2067
Ruben Brunk6267b532015-04-30 17:44:07 -07002068 // Don't evict clients that are still allowed.
2069 uid_t clientUid = clientSp->getClientUid();
2070 userid_t clientUserId = multiuser_get_user_id(clientUid);
2071 if (mAllowedUsers.find(clientUserId) != mAllowedUsers.end()) {
2072 continue;
2073 }
2074
Ruben Brunk36597b22015-03-20 22:15:57 -07002075 evicted.push_back(clientSp);
2076
2077 String8 curTime = getFormattedCurrentTime();
2078
2079 ALOGE("Evicting conflicting client for camera ID %s due to user change",
2080 i->getKey().string());
Ruben Brunka8ca9152015-04-07 14:23:40 -07002081
Ruben Brunk36597b22015-03-20 22:15:57 -07002082 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07002083 logEvent(String8::format("EVICT device %s client held by package %s (PID %"
Emilian Peev8131a262017-02-01 12:33:43 +00002084 PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted due"
2085 " to user switch.", i->getKey().string(),
2086 String8{clientSp->getPackageName()}.string(),
2087 i->getOwnerId(), i->getPriority().getScore(),
2088 i->getPriority().getState()));
Ruben Brunk36597b22015-03-20 22:15:57 -07002089
2090 }
2091
2092 // Do not hold mServiceLock while disconnecting clients, but retain the condition
2093 // blocking other clients from connecting in mServiceLockWrapper if held.
2094 mServiceLock.unlock();
2095
2096 // Clear caller identity temporarily so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -07002097 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunk36597b22015-03-20 22:15:57 -07002098
2099 for (auto& i : evicted) {
2100 i->disconnect();
2101 }
2102
Jayant Chowdhary12361932018-08-27 14:46:13 -07002103 CameraThreadState::restoreCallingIdentity(token);
Ruben Brunk36597b22015-03-20 22:15:57 -07002104
2105 // Reacquire mServiceLock
2106 mServiceLock.lock();
2107}
Ruben Brunkcc776712015-02-17 20:18:47 -08002108
Ruben Brunka8ca9152015-04-07 14:23:40 -07002109void CameraService::logEvent(const char* event) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002110 String8 curTime = getFormattedCurrentTime();
Ruben Brunka8ca9152015-04-07 14:23:40 -07002111 Mutex::Autolock l(mLogLock);
2112 mEventLog.add(String8::format("%s : %s", curTime.string(), event));
Mathias Agopian65ab4712010-07-14 17:59:35 -07002113}
2114
Ruben Brunka8ca9152015-04-07 14:23:40 -07002115void CameraService::logDisconnected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002116 const char* clientPackage) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002117 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07002118 logEvent(String8::format("DISCONNECT device %s client for package %s (PID %d)", cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002119 clientPackage, clientPid));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002120}
2121
2122void CameraService::logConnected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002123 const char* clientPackage) {
Ruben Brunka8ca9152015-04-07 14:23:40 -07002124 // Log the clients evicted
2125 logEvent(String8::format("CONNECT device %s client for package %s (PID %d)", cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002126 clientPackage, clientPid));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002127}
2128
2129void CameraService::logRejected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002130 const char* clientPackage, const char* reason) {
Ruben Brunka8ca9152015-04-07 14:23:40 -07002131 // Log the client rejected
2132 logEvent(String8::format("REJECT device %s client for package %s (PID %d), reason: (%s)",
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002133 cameraId, clientPackage, clientPid, reason));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002134}
2135
Jayant Chowdhary0e2eefd2019-04-18 14:05:43 -07002136void CameraService::logTorchEvent(const char* cameraId, const char *torchState, int clientPid) {
2137 // Log torch event
2138 logEvent(String8::format("Torch for camera id %s turned %s for client PID %d", cameraId,
2139 torchState, clientPid));
2140}
2141
Ruben Brunk6267b532015-04-30 17:44:07 -07002142void CameraService::logUserSwitch(const std::set<userid_t>& oldUserIds,
2143 const std::set<userid_t>& newUserIds) {
2144 String8 newUsers = toString(newUserIds);
2145 String8 oldUsers = toString(oldUserIds);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002146 if (oldUsers.size() == 0) {
2147 oldUsers = "<None>";
2148 }
Ruben Brunka8ca9152015-04-07 14:23:40 -07002149 // Log the new and old users
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002150 logEvent(String8::format("USER_SWITCH previous allowed user IDs: %s, current allowed user IDs: %s",
Ruben Brunk6267b532015-04-30 17:44:07 -07002151 oldUsers.string(), newUsers.string()));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002152}
2153
2154void CameraService::logDeviceRemoved(const char* cameraId, const char* reason) {
2155 // Log the device removal
2156 logEvent(String8::format("REMOVE device %s, reason: (%s)", cameraId, reason));
2157}
2158
2159void CameraService::logDeviceAdded(const char* cameraId, const char* reason) {
2160 // Log the device removal
2161 logEvent(String8::format("ADD device %s, reason: (%s)", cameraId, reason));
2162}
2163
2164void CameraService::logClientDied(int clientPid, const char* reason) {
2165 // Log the device removal
2166 logEvent(String8::format("DIED client(s) with PID %d, reason: (%s)", clientPid, reason));
Igor Murashkinecf17e82012-10-02 16:05:11 -07002167}
2168
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002169void CameraService::logServiceError(const char* msg, int errorCode) {
2170 String8 curTime = getFormattedCurrentTime();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08002171 logEvent(String8::format("SERVICE ERROR: %s : %d (%s)", msg, errorCode, strerror(-errorCode)));
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002172}
2173
Ruben Brunk36597b22015-03-20 22:15:57 -07002174status_t CameraService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
2175 uint32_t flags) {
2176
Mathias Agopian65ab4712010-07-14 17:59:35 -07002177 // Permission checks
2178 switch (code) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002179 case SHELL_COMMAND_TRANSACTION: {
2180 int in = data.readFileDescriptor();
2181 int out = data.readFileDescriptor();
2182 int err = data.readFileDescriptor();
2183 int argc = data.readInt32();
2184 Vector<String16> args;
2185 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
2186 args.add(data.readString16());
2187 }
2188 sp<IBinder> unusedCallback;
2189 sp<IResultReceiver> resultReceiver;
2190 status_t status;
2191 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
2192 return status;
2193 }
2194 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
2195 return status;
2196 }
2197 status = shellCommand(in, out, err, args);
2198 if (resultReceiver != nullptr) {
2199 resultReceiver->send(status);
2200 }
2201 return NO_ERROR;
2202 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002203 }
2204
2205 return BnCameraService::onTransact(code, data, reply, flags);
2206}
2207
Mathias Agopian65ab4712010-07-14 17:59:35 -07002208// We share the media players for shutter and recording sound for all clients.
2209// A reference count is kept to determine when we will actually release the
2210// media players.
2211
Jaekyun Seokef498052018-03-23 13:09:44 +09002212sp<MediaPlayer> CameraService::newMediaPlayer(const char *file) {
2213 sp<MediaPlayer> mp = new MediaPlayer();
2214 status_t error;
2215 if ((error = mp->setDataSource(NULL /* httpService */, file, NULL)) == NO_ERROR) {
Eino-Ville Talvala60a78ac2012-01-05 15:34:53 -08002216 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
Jaekyun Seokef498052018-03-23 13:09:44 +09002217 error = mp->prepare();
2218 }
2219 if (error != NO_ERROR) {
Steve Block29357bc2012-01-06 19:20:56 +00002220 ALOGE("Failed to load CameraService sounds: %s", file);
Jaekyun Seokef498052018-03-23 13:09:44 +09002221 mp->disconnect();
2222 mp.clear();
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002223 return nullptr;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002224 }
2225 return mp;
2226}
2227
username5755fea2018-12-27 09:48:08 +08002228void CameraService::increaseSoundRef() {
2229 Mutex::Autolock lock(mSoundLock);
2230 mSoundRef++;
2231}
2232
2233void CameraService::loadSoundLocked(sound_kind kind) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002234 ATRACE_CALL();
2235
username5755fea2018-12-27 09:48:08 +08002236 LOG1("CameraService::loadSoundLocked ref=%d", mSoundRef);
2237 if (SOUND_SHUTTER == kind && mSoundPlayer[SOUND_SHUTTER] == NULL) {
2238 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/product/media/audio/ui/camera_click.ogg");
2239 if (mSoundPlayer[SOUND_SHUTTER] == nullptr) {
2240 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
2241 }
2242 } else if (SOUND_RECORDING_START == kind && mSoundPlayer[SOUND_RECORDING_START] == NULL) {
2243 mSoundPlayer[SOUND_RECORDING_START] = newMediaPlayer("/product/media/audio/ui/VideoRecord.ogg");
2244 if (mSoundPlayer[SOUND_RECORDING_START] == nullptr) {
2245 mSoundPlayer[SOUND_RECORDING_START] =
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002246 newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
username5755fea2018-12-27 09:48:08 +08002247 }
2248 } else if (SOUND_RECORDING_STOP == kind && mSoundPlayer[SOUND_RECORDING_STOP] == NULL) {
2249 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/product/media/audio/ui/VideoStop.ogg");
2250 if (mSoundPlayer[SOUND_RECORDING_STOP] == nullptr) {
2251 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/system/media/audio/ui/VideoStop.ogg");
2252 }
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002253 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002254}
2255
username5755fea2018-12-27 09:48:08 +08002256void CameraService::decreaseSoundRef() {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002257 Mutex::Autolock lock(mSoundLock);
username5755fea2018-12-27 09:48:08 +08002258 LOG1("CameraService::decreaseSoundRef ref=%d", mSoundRef);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002259 if (--mSoundRef) return;
2260
2261 for (int i = 0; i < NUM_SOUNDS; i++) {
2262 if (mSoundPlayer[i] != 0) {
2263 mSoundPlayer[i]->disconnect();
2264 mSoundPlayer[i].clear();
2265 }
2266 }
2267}
2268
2269void CameraService::playSound(sound_kind kind) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002270 ATRACE_CALL();
2271
Mathias Agopian65ab4712010-07-14 17:59:35 -07002272 LOG1("playSound(%d)", kind);
2273 Mutex::Autolock lock(mSoundLock);
username5755fea2018-12-27 09:48:08 +08002274 loadSoundLocked(kind);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002275 sp<MediaPlayer> player = mSoundPlayer[kind];
2276 if (player != 0) {
Chih-Chung Chang8888a752011-10-20 10:47:26 +08002277 player->seekTo(0);
2278 player->start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002279 }
2280}
2281
2282// ----------------------------------------------------------------------------
2283
2284CameraService::Client::Client(const sp<CameraService>& cameraService,
Wu-cheng Lib7a67942010-08-17 15:45:37 -07002285 const sp<ICameraClient>& cameraClient,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002286 const String16& clientPackageName,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002287 const String8& cameraIdStr,
2288 int api1CameraId, int cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002289 int clientPid, uid_t clientUid,
2290 int servicePid) :
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08002291 CameraService::BasicClient(cameraService,
Marco Nelissenf8880202014-11-14 07:58:25 -08002292 IInterface::asBinder(cameraClient),
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002293 clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002294 cameraIdStr, cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002295 clientPid, clientUid,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002296 servicePid),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002297 mCameraId(api1CameraId)
Igor Murashkin634a5152013-02-20 17:15:11 -08002298{
Jayant Chowdhary12361932018-08-27 14:46:13 -07002299 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002300 LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002301
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002302 mRemoteCallback = cameraClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002303
username5755fea2018-12-27 09:48:08 +08002304 cameraService->increaseSoundRef();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002305
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002306 LOG1("Client::Client X (pid %d, id %d)", callingPid, mCameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002307}
2308
Mathias Agopian65ab4712010-07-14 17:59:35 -07002309// tear down the client
2310CameraService::Client::~Client() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002311 ALOGV("~Client");
Igor Murashkin634a5152013-02-20 17:15:11 -08002312 mDestructionStarted = true;
2313
username5755fea2018-12-27 09:48:08 +08002314 sCameraService->decreaseSoundRef();
Igor Murashkin036bc3e2012-10-08 15:09:46 -07002315 // unconditionally disconnect. function is idempotent
2316 Client::disconnect();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002317}
2318
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002319sp<CameraService> CameraService::BasicClient::BasicClient::sCameraService;
2320
Igor Murashkin634a5152013-02-20 17:15:11 -08002321CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002322 const sp<IBinder>& remoteCallback,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002323 const String16& clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002324 const String8& cameraIdStr, int cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002325 int clientPid, uid_t clientUid,
2326 int servicePid):
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002327 mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing),
2328 mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid),
2329 mServicePid(servicePid),
2330 mDisconnected(false),
2331 mRemoteBinder(remoteCallback)
Igor Murashkin634a5152013-02-20 17:15:11 -08002332{
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002333 if (sCameraService == nullptr) {
2334 sCameraService = cameraService;
2335 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002336 mOpsActive = false;
Igor Murashkin634a5152013-02-20 17:15:11 -08002337 mDestructionStarted = false;
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -08002338
2339 // In some cases the calling code has no access to the package it runs under.
2340 // For example, NDK camera API.
2341 // In this case we will get the packages for the calling UID and pick the first one
2342 // for attributing the app op. This will work correctly for runtime permissions
2343 // as for legacy apps we will toggle the app op for all packages in the UID.
2344 // The caveat is that the operation may be attributed to the wrong package and
2345 // stats based on app ops may be slightly off.
2346 if (mClientPackageName.size() <= 0) {
2347 sp<IServiceManager> sm = defaultServiceManager();
2348 sp<IBinder> binder = sm->getService(String16(kPermissionServiceName));
2349 if (binder == 0) {
2350 ALOGE("Cannot get permission service");
2351 // Leave mClientPackageName unchanged (empty) and the further interaction
2352 // with camera will fail in BasicClient::startCameraOps
2353 return;
2354 }
2355
2356 sp<IPermissionController> permCtrl = interface_cast<IPermissionController>(binder);
2357 Vector<String16> packages;
2358
2359 permCtrl->getPackagesForUid(mClientUid, packages);
2360
2361 if (packages.isEmpty()) {
2362 ALOGE("No packages for calling UID");
2363 // Leave mClientPackageName unchanged (empty) and the further interaction
2364 // with camera will fail in BasicClient::startCameraOps
2365 return;
2366 }
2367 mClientPackageName = packages[0];
2368 }
Igor Murashkin634a5152013-02-20 17:15:11 -08002369}
2370
2371CameraService::BasicClient::~BasicClient() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002372 ALOGV("~BasicClient");
Igor Murashkin634a5152013-02-20 17:15:11 -08002373 mDestructionStarted = true;
2374}
2375
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002376binder::Status CameraService::BasicClient::disconnect() {
2377 binder::Status res = Status::ok();
Ruben Brunk36597b22015-03-20 22:15:57 -07002378 if (mDisconnected) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002379 return res;
Ruben Brunk36597b22015-03-20 22:15:57 -07002380 }
Eino-Ville Talvala24901c82015-09-04 14:15:58 -07002381 mDisconnected = true;
Ruben Brunkcc776712015-02-17 20:18:47 -08002382
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002383 sCameraService->removeByClient(this);
2384 sCameraService->logDisconnected(mCameraIdStr, mClientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002385 String8(mClientPackageName));
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002386 sCameraService->mCameraProviderManager->removeRef(CameraProviderManager::DeviceMode::CAMERA,
2387 mCameraIdStr.c_str());
Ruben Brunkcc776712015-02-17 20:18:47 -08002388
2389 sp<IBinder> remote = getRemote();
2390 if (remote != nullptr) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002391 remote->unlinkToDeath(sCameraService);
Ruben Brunkcc776712015-02-17 20:18:47 -08002392 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002393
2394 finishCameraOps();
Chien-Yu Chene4fe21b2016-08-04 12:42:40 -07002395 // Notify flashlight that a camera device is closed.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002396 sCameraService->mFlashlight->deviceClosed(mCameraIdStr);
2397 ALOGI("%s: Disconnected client for camera %s for PID %d", __FUNCTION__, mCameraIdStr.string(),
2398 mClientPid);
Ruben Brunkcc776712015-02-17 20:18:47 -08002399
Igor Murashkincba2c162013-03-20 15:56:31 -07002400 // client shouldn't be able to call into us anymore
2401 mClientPid = 0;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002402
2403 return res;
Igor Murashkin634a5152013-02-20 17:15:11 -08002404}
2405
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08002406status_t CameraService::BasicClient::dump(int, const Vector<String16>&) {
2407 // No dumping of clients directly over Binder,
2408 // must go through CameraService::dump
2409 android_errorWriteWithInfoLog(SN_EVENT_LOG_ID, "26265403",
Jayant Chowdhary12361932018-08-27 14:46:13 -07002410 CameraThreadState::getCallingUid(), NULL, 0);
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08002411 return OK;
2412}
2413
Ruben Brunkcc776712015-02-17 20:18:47 -08002414String16 CameraService::BasicClient::getPackageName() const {
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002415 return mClientPackageName;
Ruben Brunkcc776712015-02-17 20:18:47 -08002416}
2417
2418
2419int CameraService::BasicClient::getClientPid() const {
2420 return mClientPid;
2421}
2422
Ruben Brunk6267b532015-04-30 17:44:07 -07002423uid_t CameraService::BasicClient::getClientUid() const {
2424 return mClientUid;
2425}
2426
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07002427bool CameraService::BasicClient::canCastToApiClient(apiLevel level) const {
2428 // Defaults to API2.
2429 return level == API_2;
2430}
2431
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002432status_t CameraService::BasicClient::startCameraOps() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002433 ATRACE_CALL();
2434
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002435 int32_t res;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002436 // Notify app ops that the camera is not available
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002437 mOpsCallback = new OpsCallback(this);
2438
Igor Murashkine6800ce2013-03-04 17:25:57 -08002439 {
2440 ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002441 __FUNCTION__, String8(mClientPackageName).string(), mClientUid);
Igor Murashkine6800ce2013-03-04 17:25:57 -08002442 }
2443
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002444 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002445 mClientPackageName, mOpsCallback);
Svet Ganov1d519102018-02-26 10:48:14 -08002446 res = mAppOpsManager.startOpNoThrow(AppOpsManager::OP_CAMERA,
2447 mClientUid, mClientPackageName, /*startIfModeDefault*/ false);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002448
Svetoslav28e8ef72015-05-11 19:21:31 -07002449 if (res == AppOpsManager::MODE_ERRORED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002450 ALOGI("Camera %s: Access for \"%s\" has been revoked",
2451 mCameraIdStr.string(), String8(mClientPackageName).string());
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002452 return PERMISSION_DENIED;
2453 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002454
Svetoslav28e8ef72015-05-11 19:21:31 -07002455 if (res == AppOpsManager::MODE_IGNORED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002456 ALOGI("Camera %s: Access for \"%s\" has been restricted",
2457 mCameraIdStr.string(), String8(mClientPackageName).string());
Eino-Ville Talvalae3afb2c2015-06-03 16:03:30 -07002458 // Return the same error as for device policy manager rejection
2459 return -EACCES;
Svetoslav28e8ef72015-05-11 19:21:31 -07002460 }
2461
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002462 mOpsActive = true;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002463
2464 // Transition device availability listeners from PRESENT -> NOT_AVAILABLE
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002465 sCameraService->updateStatus(StatusInternal::NOT_AVAILABLE, mCameraIdStr);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002466
Emilian Peev573291c2018-02-10 02:10:56 +00002467 int apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_1;
2468 if (canCastToApiClient(API_2)) {
2469 apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_2;
2470 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002471 // Transition device state to OPEN
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002472 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
Emilian Peev573291c2018-02-10 02:10:56 +00002473 mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002474
Emilian Peev53722fa2019-02-22 17:47:20 -08002475 sCameraService->mUidPolicy->registerMonitorUid(mClientUid);
2476
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002477 return OK;
2478}
2479
2480status_t CameraService::BasicClient::finishCameraOps() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002481 ATRACE_CALL();
2482
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002483 // Check if startCameraOps succeeded, and if so, finish the camera op
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002484 if (mOpsActive) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002485 // Notify app ops that the camera is available again
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002486 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002487 mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002488 mOpsActive = false;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002489
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002490 // This function is called when a client disconnects. This should
2491 // release the camera, but actually only if it was in a proper
2492 // functional state, i.e. with status NOT_AVAILABLE
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002493 std::initializer_list<StatusInternal> rejected = {StatusInternal::PRESENT,
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002494 StatusInternal::ENUMERATING, StatusInternal::NOT_PRESENT};
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002495
Ruben Brunkcc776712015-02-17 20:18:47 -08002496 // Transition to PRESENT if the camera is not in either of the rejected states
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002497 sCameraService->updateStatus(StatusInternal::PRESENT,
2498 mCameraIdStr, rejected);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002499
Emilian Peev573291c2018-02-10 02:10:56 +00002500 int apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_1;
2501 if (canCastToApiClient(API_2)) {
2502 apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_2;
2503 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002504 // Transition device state to CLOSED
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002505 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED,
Emilian Peev573291c2018-02-10 02:10:56 +00002506 mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002507 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002508 // Always stop watching, even if no camera op is active
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08002509 if (mOpsCallback != NULL) {
2510 mAppOpsManager.stopWatchingMode(mOpsCallback);
2511 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002512 mOpsCallback.clear();
2513
Emilian Peev53722fa2019-02-22 17:47:20 -08002514 sCameraService->mUidPolicy->unregisterMonitorUid(mClientUid);
2515
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002516 return OK;
2517}
2518
2519void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002520 ATRACE_CALL();
2521
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002522 String8 name(packageName);
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002523 String8 myName(mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002524
2525 if (op != AppOpsManager::OP_CAMERA) {
2526 ALOGW("Unexpected app ops notification received: %d", op);
2527 return;
2528 }
2529
2530 int32_t res;
2531 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002532 mClientUid, mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002533 ALOGV("checkOp returns: %d, %s ", res,
2534 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" :
2535 res == AppOpsManager::MODE_IGNORED ? "IGNORED" :
2536 res == AppOpsManager::MODE_ERRORED ? "ERRORED" :
2537 "UNKNOWN");
2538
2539 if (res != AppOpsManager::MODE_ALLOWED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002540 ALOGI("Camera %s: Access for \"%s\" revoked", mCameraIdStr.string(),
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002541 myName.string());
Svet Ganova453d0d2018-01-11 15:37:58 -08002542 block();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002543 }
2544}
2545
Svet Ganova453d0d2018-01-11 15:37:58 -08002546void CameraService::BasicClient::block() {
2547 ATRACE_CALL();
2548
2549 // Reset the client PID to allow server-initiated disconnect,
2550 // and to prevent further calls by client.
Jayant Chowdhary12361932018-08-27 14:46:13 -07002551 mClientPid = CameraThreadState::getCallingPid();
Svet Ganova453d0d2018-01-11 15:37:58 -08002552 CaptureResultExtras resultExtras; // a dummy result (invalid)
2553 notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED, resultExtras);
2554 disconnect();
2555}
2556
Mathias Agopian65ab4712010-07-14 17:59:35 -07002557// ----------------------------------------------------------------------------
2558
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002559void CameraService::Client::notifyError(int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -07002560 const CaptureResultExtras& resultExtras) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08002561 (void) resultExtras;
Ranjith Kagathi Ananda3e600892015-10-08 16:00:33 -07002562 if (mRemoteCallback != NULL) {
Yin-Chia Yehf13bda52018-05-31 12:12:59 -07002563 int32_t api1ErrorCode = CAMERA_ERROR_RELEASED;
2564 if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED) {
2565 api1ErrorCode = CAMERA_ERROR_DISABLED;
2566 }
2567 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, api1ErrorCode, 0);
Ranjith Kagathi Ananda3e600892015-10-08 16:00:33 -07002568 } else {
2569 ALOGE("mRemoteCallback is NULL!!");
2570 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002571}
2572
Igor Murashkin036bc3e2012-10-08 15:09:46 -07002573// NOTE: function is idempotent
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002574binder::Status CameraService::Client::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002575 ALOGV("Client::disconnect");
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002576 return BasicClient::disconnect();
Wu-cheng Lie09591e2010-10-14 20:17:44 +08002577}
2578
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07002579bool CameraService::Client::canCastToApiClient(apiLevel level) const {
2580 return level == API_1;
2581}
2582
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002583CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client):
2584 mClient(client) {
2585}
2586
2587void CameraService::Client::OpsCallback::opChanged(int32_t op,
2588 const String16& packageName) {
2589 sp<BasicClient> client = mClient.promote();
2590 if (client != NULL) {
2591 client->opChanged(op, packageName);
2592 }
2593}
2594
Mathias Agopian65ab4712010-07-14 17:59:35 -07002595// ----------------------------------------------------------------------------
Svet Ganova453d0d2018-01-11 15:37:58 -08002596// UidPolicy
2597// ----------------------------------------------------------------------------
2598
2599void CameraService::UidPolicy::registerSelf() {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002600 Mutex::Autolock _l(mUidLock);
2601
Svet Ganova453d0d2018-01-11 15:37:58 -08002602 ActivityManager am;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002603 if (mRegistered) return;
Svet Ganova453d0d2018-01-11 15:37:58 -08002604 am.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
2605 | ActivityManager::UID_OBSERVER_IDLE
Emilian Peev53722fa2019-02-22 17:47:20 -08002606 | ActivityManager::UID_OBSERVER_ACTIVE | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganova453d0d2018-01-11 15:37:58 -08002607 ActivityManager::PROCESS_STATE_UNKNOWN,
2608 String16("cameraserver"));
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002609 status_t res = am.linkToDeath(this);
2610 if (res == OK) {
2611 mRegistered = true;
2612 ALOGV("UidPolicy: Registered with ActivityManager");
2613 }
Svet Ganova453d0d2018-01-11 15:37:58 -08002614}
2615
2616void CameraService::UidPolicy::unregisterSelf() {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002617 Mutex::Autolock _l(mUidLock);
2618
Svet Ganova453d0d2018-01-11 15:37:58 -08002619 ActivityManager am;
2620 am.unregisterUidObserver(this);
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002621 am.unlinkToDeath(this);
2622 mRegistered = false;
2623 mActiveUids.clear();
2624 ALOGV("UidPolicy: Unregistered with ActivityManager");
Svet Ganova453d0d2018-01-11 15:37:58 -08002625}
2626
2627void CameraService::UidPolicy::onUidGone(uid_t uid, bool disabled) {
2628 onUidIdle(uid, disabled);
2629}
2630
2631void CameraService::UidPolicy::onUidActive(uid_t uid) {
2632 Mutex::Autolock _l(mUidLock);
2633 mActiveUids.insert(uid);
2634}
2635
2636void CameraService::UidPolicy::onUidIdle(uid_t uid, bool /* disabled */) {
2637 bool deleted = false;
2638 {
2639 Mutex::Autolock _l(mUidLock);
2640 if (mActiveUids.erase(uid) > 0) {
2641 deleted = true;
2642 }
2643 }
2644 if (deleted) {
2645 sp<CameraService> service = mService.promote();
2646 if (service != nullptr) {
2647 service->blockClientsForUid(uid);
2648 }
2649 }
2650}
2651
Emilian Peev53722fa2019-02-22 17:47:20 -08002652void CameraService::UidPolicy::onUidStateChanged(uid_t uid, int32_t procState,
2653 int64_t /*procStateSeq*/) {
2654 bool procStateChange = false;
2655 {
2656 Mutex::Autolock _l(mUidLock);
2657 if ((mMonitoredUids.find(uid) != mMonitoredUids.end()) &&
2658 (mMonitoredUids[uid].first != procState)) {
2659 mMonitoredUids[uid].first = procState;
2660 procStateChange = true;
2661 }
2662 }
2663
2664 if (procStateChange) {
2665 sp<CameraService> service = mService.promote();
2666 if (service != nullptr) {
2667 service->notifyMonitoredUids();
2668 }
2669 }
2670}
2671
2672void CameraService::UidPolicy::registerMonitorUid(uid_t uid) {
2673 Mutex::Autolock _l(mUidLock);
2674 auto it = mMonitoredUids.find(uid);
2675 if (it != mMonitoredUids.end()) {
2676 it->second.second++;
2677 } else {
2678 mMonitoredUids.emplace(
2679 std::pair<uid_t, std::pair<int32_t, size_t>> (uid,
2680 std::pair<int32_t, size_t> (ActivityManager::PROCESS_STATE_NONEXISTENT, 1)));
2681 }
2682}
2683
2684void CameraService::UidPolicy::unregisterMonitorUid(uid_t uid) {
2685 Mutex::Autolock _l(mUidLock);
2686 auto it = mMonitoredUids.find(uid);
2687 if (it != mMonitoredUids.end()) {
2688 it->second.second--;
2689 if (it->second.second == 0) {
2690 mMonitoredUids.erase(it);
2691 }
2692 } else {
2693 ALOGE("%s: Trying to unregister uid: %d which is not monitored!", __FUNCTION__, uid);
2694 }
2695}
2696
Svet Ganov7b4ab782018-03-25 12:48:10 -07002697bool CameraService::UidPolicy::isUidActive(uid_t uid, String16 callingPackage) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002698 Mutex::Autolock _l(mUidLock);
Svet Ganov7b4ab782018-03-25 12:48:10 -07002699 return isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002700}
2701
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002702static const int64_t kPollUidActiveTimeoutTotalMillis = 300;
2703static const int64_t kPollUidActiveTimeoutMillis = 50;
Svet Ganov94ec46f2018-06-08 15:03:46 -07002704
Svet Ganov7b4ab782018-03-25 12:48:10 -07002705bool CameraService::UidPolicy::isUidActiveLocked(uid_t uid, String16 callingPackage) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002706 // Non-app UIDs are considered always active
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002707 // If activity manager is unreachable, assume everything is active
2708 if (uid < FIRST_APPLICATION_UID || !mRegistered) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002709 return true;
2710 }
2711 auto it = mOverrideUids.find(uid);
2712 if (it != mOverrideUids.end()) {
2713 return it->second;
2714 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07002715 bool active = mActiveUids.find(uid) != mActiveUids.end();
2716 if (!active) {
2717 // We want active UIDs to always access camera with their first attempt since
2718 // there is no guarantee the app is robustly written and would retry getting
2719 // the camera on failure. The inverse case is not a problem as we would take
2720 // camera away soon once we get the callback that the uid is no longer active.
2721 ActivityManager am;
2722 // Okay to access with a lock held as UID changes are dispatched without
2723 // a lock and we are a higher level component.
Svet Ganov94ec46f2018-06-08 15:03:46 -07002724 int64_t startTimeMillis = 0;
2725 do {
2726 // TODO: Fix this b/109950150!
2727 // Okay this is a hack. There is a race between the UID turning active and
2728 // activity being resumed. The proper fix is very risky, so we temporary add
2729 // some polling which should happen pretty rarely anyway as the race is hard
2730 // to hit.
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002731 active = mActiveUids.find(uid) != mActiveUids.end();
2732 if (!active) active = am.isUidActive(uid, callingPackage);
Svet Ganov94ec46f2018-06-08 15:03:46 -07002733 if (active) {
2734 break;
2735 }
2736 if (startTimeMillis <= 0) {
2737 startTimeMillis = uptimeMillis();
2738 }
2739 int64_t ellapsedTimeMillis = uptimeMillis() - startTimeMillis;
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002740 int64_t remainingTimeMillis = kPollUidActiveTimeoutTotalMillis - ellapsedTimeMillis;
Svet Ganov94ec46f2018-06-08 15:03:46 -07002741 if (remainingTimeMillis <= 0) {
2742 break;
2743 }
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002744 remainingTimeMillis = std::min(kPollUidActiveTimeoutMillis, remainingTimeMillis);
2745
2746 mUidLock.unlock();
Svet Ganov94ec46f2018-06-08 15:03:46 -07002747 usleep(remainingTimeMillis * 1000);
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002748 mUidLock.lock();
Svet Ganov94ec46f2018-06-08 15:03:46 -07002749 } while (true);
2750
Svet Ganov7b4ab782018-03-25 12:48:10 -07002751 if (active) {
2752 // Now that we found out the UID is actually active, cache that
2753 mActiveUids.insert(uid);
2754 }
2755 }
2756 return active;
Svet Ganova453d0d2018-01-11 15:37:58 -08002757}
2758
Varun Shahb42f1eb2019-04-16 14:45:13 -07002759int32_t CameraService::UidPolicy::getProcState(uid_t uid) {
2760 Mutex::Autolock _l(mUidLock);
2761 return getProcStateLocked(uid);
2762}
2763
2764int32_t CameraService::UidPolicy::getProcStateLocked(uid_t uid) {
2765 int32_t procState = ActivityManager::PROCESS_STATE_UNKNOWN;
2766 if (mMonitoredUids.find(uid) != mMonitoredUids.end()) {
2767 procState = mMonitoredUids[uid].first;
2768 }
2769 return procState;
2770}
2771
Svet Ganov7b4ab782018-03-25 12:48:10 -07002772void CameraService::UidPolicy::UidPolicy::addOverrideUid(uid_t uid,
2773 String16 callingPackage, bool active) {
2774 updateOverrideUid(uid, callingPackage, active, true);
Svet Ganova453d0d2018-01-11 15:37:58 -08002775}
2776
Svet Ganov7b4ab782018-03-25 12:48:10 -07002777void CameraService::UidPolicy::removeOverrideUid(uid_t uid, String16 callingPackage) {
2778 updateOverrideUid(uid, callingPackage, false, false);
Svet Ganova453d0d2018-01-11 15:37:58 -08002779}
2780
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002781void CameraService::UidPolicy::binderDied(const wp<IBinder>& /*who*/) {
2782 Mutex::Autolock _l(mUidLock);
2783 ALOGV("UidPolicy: ActivityManager has died");
2784 mRegistered = false;
2785 mActiveUids.clear();
2786}
2787
Svet Ganov7b4ab782018-03-25 12:48:10 -07002788void CameraService::UidPolicy::updateOverrideUid(uid_t uid, String16 callingPackage,
2789 bool active, bool insert) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002790 bool wasActive = false;
2791 bool isActive = false;
2792 {
2793 Mutex::Autolock _l(mUidLock);
Svet Ganov7b4ab782018-03-25 12:48:10 -07002794 wasActive = isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002795 mOverrideUids.erase(uid);
2796 if (insert) {
2797 mOverrideUids.insert(std::pair<uid_t, bool>(uid, active));
2798 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07002799 isActive = isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002800 }
2801 if (wasActive != isActive && !isActive) {
2802 sp<CameraService> service = mService.promote();
2803 if (service != nullptr) {
2804 service->blockClientsForUid(uid);
2805 }
2806 }
2807}
2808
2809// ----------------------------------------------------------------------------
Michael Grooverd1d435a2018-12-18 17:39:42 -08002810// SensorPrivacyPolicy
2811// ----------------------------------------------------------------------------
2812void CameraService::SensorPrivacyPolicy::registerSelf() {
2813 Mutex::Autolock _l(mSensorPrivacyLock);
2814 if (mRegistered) {
2815 return;
2816 }
2817 SensorPrivacyManager spm;
2818 spm.addSensorPrivacyListener(this);
2819 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
2820 status_t res = spm.linkToDeath(this);
2821 if (res == OK) {
2822 mRegistered = true;
2823 ALOGV("SensorPrivacyPolicy: Registered with SensorPrivacyManager");
2824 }
2825}
2826
2827void CameraService::SensorPrivacyPolicy::unregisterSelf() {
2828 Mutex::Autolock _l(mSensorPrivacyLock);
2829 SensorPrivacyManager spm;
2830 spm.removeSensorPrivacyListener(this);
2831 spm.unlinkToDeath(this);
2832 mRegistered = false;
2833 ALOGV("SensorPrivacyPolicy: Unregistered with SensorPrivacyManager");
2834}
2835
2836bool CameraService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
2837 Mutex::Autolock _l(mSensorPrivacyLock);
2838 return mSensorPrivacyEnabled;
2839}
2840
2841binder::Status CameraService::SensorPrivacyPolicy::onSensorPrivacyChanged(bool enabled) {
2842 {
2843 Mutex::Autolock _l(mSensorPrivacyLock);
2844 mSensorPrivacyEnabled = enabled;
2845 }
2846 // if sensor privacy is enabled then block all clients from accessing the camera
2847 if (enabled) {
2848 sp<CameraService> service = mService.promote();
2849 if (service != nullptr) {
2850 service->blockAllClients();
2851 }
2852 }
2853 return binder::Status::ok();
2854}
2855
2856void CameraService::SensorPrivacyPolicy::binderDied(const wp<IBinder>& /*who*/) {
2857 Mutex::Autolock _l(mSensorPrivacyLock);
2858 ALOGV("SensorPrivacyPolicy: SensorPrivacyManager has died");
2859 mRegistered = false;
2860}
2861
2862// ----------------------------------------------------------------------------
Ruben Brunkcc776712015-02-17 20:18:47 -08002863// CameraState
2864// ----------------------------------------------------------------------------
2865
2866CameraService::CameraState::CameraState(const String8& id, int cost,
2867 const std::set<String8>& conflicting) : mId(id),
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002868 mStatus(StatusInternal::NOT_PRESENT), mCost(cost), mConflicting(conflicting) {}
Ruben Brunkcc776712015-02-17 20:18:47 -08002869
2870CameraService::CameraState::~CameraState() {}
2871
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002872CameraService::StatusInternal CameraService::CameraState::getStatus() const {
Ruben Brunkcc776712015-02-17 20:18:47 -08002873 Mutex::Autolock lock(mStatusLock);
2874 return mStatus;
2875}
2876
2877CameraParameters CameraService::CameraState::getShimParams() const {
2878 return mShimParams;
2879}
2880
2881void CameraService::CameraState::setShimParams(const CameraParameters& params) {
2882 mShimParams = params;
2883}
2884
2885int CameraService::CameraState::getCost() const {
2886 return mCost;
2887}
2888
2889std::set<String8> CameraService::CameraState::getConflicting() const {
2890 return mConflicting;
2891}
2892
2893String8 CameraService::CameraState::getId() const {
2894 return mId;
2895}
2896
2897// ----------------------------------------------------------------------------
Ruben Brunk99e69712015-05-26 17:25:07 -07002898// ClientEventListener
2899// ----------------------------------------------------------------------------
2900
2901void CameraService::ClientEventListener::onClientAdded(
2902 const resource_policy::ClientDescriptor<String8,
2903 sp<CameraService::BasicClient>>& descriptor) {
Chih-Hung Hsieh5404ee12016-08-09 14:25:53 -07002904 const auto& basicClient = descriptor.getValue();
Ruben Brunk99e69712015-05-26 17:25:07 -07002905 if (basicClient.get() != nullptr) {
2906 BatteryNotifier& notifier(BatteryNotifier::getInstance());
2907 notifier.noteStartCamera(descriptor.getKey(),
2908 static_cast<int>(basicClient->getClientUid()));
2909 }
2910}
2911
2912void CameraService::ClientEventListener::onClientRemoved(
2913 const resource_policy::ClientDescriptor<String8,
2914 sp<CameraService::BasicClient>>& descriptor) {
Chih-Hung Hsieh5404ee12016-08-09 14:25:53 -07002915 const auto& basicClient = descriptor.getValue();
Ruben Brunk99e69712015-05-26 17:25:07 -07002916 if (basicClient.get() != nullptr) {
2917 BatteryNotifier& notifier(BatteryNotifier::getInstance());
2918 notifier.noteStopCamera(descriptor.getKey(),
2919 static_cast<int>(basicClient->getClientUid()));
2920 }
2921}
2922
2923
2924// ----------------------------------------------------------------------------
Ruben Brunkcc776712015-02-17 20:18:47 -08002925// CameraClientManager
2926// ----------------------------------------------------------------------------
2927
Ruben Brunk99e69712015-05-26 17:25:07 -07002928CameraService::CameraClientManager::CameraClientManager() {
2929 setListener(std::make_shared<ClientEventListener>());
2930}
2931
Ruben Brunkcc776712015-02-17 20:18:47 -08002932CameraService::CameraClientManager::~CameraClientManager() {}
2933
2934sp<CameraService::BasicClient> CameraService::CameraClientManager::getCameraClient(
2935 const String8& id) const {
2936 auto descriptor = get(id);
2937 if (descriptor == nullptr) {
2938 return sp<BasicClient>{nullptr};
2939 }
2940 return descriptor->getValue();
2941}
2942
2943String8 CameraService::CameraClientManager::toString() const {
2944 auto all = getAll();
2945 String8 ret("[");
2946 bool hasAny = false;
2947 for (auto& i : all) {
2948 hasAny = true;
2949 String8 key = i->getKey();
2950 int32_t cost = i->getCost();
2951 int32_t pid = i->getOwnerId();
Emilian Peev8131a262017-02-01 12:33:43 +00002952 int32_t score = i->getPriority().getScore();
2953 int32_t state = i->getPriority().getState();
Ruben Brunkcc776712015-02-17 20:18:47 -08002954 auto conflicting = i->getConflicting();
2955 auto clientSp = i->getValue();
2956 String8 packageName;
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07002957 userid_t clientUserId = 0;
Ruben Brunkcc776712015-02-17 20:18:47 -08002958 if (clientSp.get() != nullptr) {
2959 packageName = String8{clientSp->getPackageName()};
Ruben Brunk6267b532015-04-30 17:44:07 -07002960 uid_t clientUid = clientSp->getClientUid();
2961 clientUserId = multiuser_get_user_id(clientUid);
Ruben Brunkcc776712015-02-17 20:18:47 -08002962 }
Emilian Peev8131a262017-02-01 12:33:43 +00002963 ret.appendFormat("\n(Camera ID: %s, Cost: %" PRId32 ", PID: %" PRId32 ", Score: %"
2964 PRId32 ", State: %" PRId32, key.string(), cost, pid, score, state);
Ruben Brunkcc776712015-02-17 20:18:47 -08002965
Ruben Brunk6267b532015-04-30 17:44:07 -07002966 if (clientSp.get() != nullptr) {
2967 ret.appendFormat("User Id: %d, ", clientUserId);
2968 }
Ruben Brunkcc776712015-02-17 20:18:47 -08002969 if (packageName.size() != 0) {
2970 ret.appendFormat("Client Package Name: %s", packageName.string());
2971 }
2972
2973 ret.append(", Conflicting Client Devices: {");
2974 for (auto& j : conflicting) {
2975 ret.appendFormat("%s, ", j.string());
2976 }
2977 ret.append("})");
2978 }
2979 if (hasAny) ret.append("\n");
2980 ret.append("]\n");
2981 return ret;
2982}
2983
2984CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2985 const String8& key, const sp<BasicClient>& value, int32_t cost,
Emilian Peev8131a262017-02-01 12:33:43 +00002986 const std::set<String8>& conflictingKeys, int32_t score, int32_t ownerId,
2987 int32_t state) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002988
Jayant Chowdharyc578a502019-05-08 10:57:54 -07002989 bool isVendorClient = hardware::IPCThreadState::self()->isServingCall();
2990 int32_t score_adj = isVendorClient ? kVendorClientScore : score;
2991 int32_t state_adj = isVendorClient ? kVendorClientState: state;
2992
Ruben Brunkcc776712015-02-17 20:18:47 -08002993 return std::make_shared<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>(
Jayant Chowdharyc578a502019-05-08 10:57:54 -07002994 key, value, cost, conflictingKeys, score_adj, ownerId, state_adj, isVendorClient);
Ruben Brunkcc776712015-02-17 20:18:47 -08002995}
2996
2997CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2998 const sp<BasicClient>& value, const CameraService::DescriptorPtr& partial) {
2999 return makeClientDescriptor(partial->getKey(), value, partial->getCost(),
Emilian Peev8131a262017-02-01 12:33:43 +00003000 partial->getConflicting(), partial->getPriority().getScore(),
3001 partial->getOwnerId(), partial->getPriority().getState());
Ruben Brunkcc776712015-02-17 20:18:47 -08003002}
3003
3004// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -07003005
3006static const int kDumpLockRetries = 50;
3007static const int kDumpLockSleep = 60000;
3008
3009static bool tryLock(Mutex& mutex)
3010{
3011 bool locked = false;
3012 for (int i = 0; i < kDumpLockRetries; ++i) {
3013 if (mutex.tryLock() == NO_ERROR) {
3014 locked = true;
3015 break;
3016 }
3017 usleep(kDumpLockSleep);
3018 }
3019 return locked;
3020}
3021
3022status_t CameraService::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07003023 ATRACE_CALL();
3024
Mathias Agopian65ab4712010-07-14 17:59:35 -07003025 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003026 dprintf(fd, "Permission Denial: can't dump CameraService from pid=%d, uid=%d\n",
Jayant Chowdhary12361932018-08-27 14:46:13 -07003027 CameraThreadState::getCallingPid(),
3028 CameraThreadState::getCallingUid());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003029 return NO_ERROR;
3030 }
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003031 bool locked = tryLock(mServiceLock);
3032 // failed to lock - CameraService is probably deadlocked
3033 if (!locked) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003034 dprintf(fd, "!! CameraService may be deadlocked !!\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003035 }
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003036
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003037 if (!mInitialized) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003038 dprintf(fd, "!! No camera HAL available !!\n");
Ruben Brunkf81648e2014-04-17 16:14:57 -07003039
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003040 // Dump event log for error information
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003041 dumpEventLog(fd);
Ruben Brunkcc776712015-02-17 20:18:47 -08003042
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003043 if (locked) mServiceLock.unlock();
3044 return NO_ERROR;
3045 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003046 dprintf(fd, "\n== Service global info: ==\n\n");
3047 dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08003048 dprintf(fd, "Number of normal camera devices: %zu\n", mNormalDeviceIds.size());
3049 for (size_t i = 0; i < mNormalDeviceIds.size(); i++) {
3050 dprintf(fd, " Device %zu maps to \"%s\"\n", i, mNormalDeviceIds[i].c_str());
3051 }
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003052 String8 activeClientString = mActiveClientManager.toString();
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003053 dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());
3054 dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003055
3056 dumpEventLog(fd);
3057
3058 bool stateLocked = tryLock(mCameraStatesLock);
3059 if (!stateLocked) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003060 dprintf(fd, "CameraStates in use, may be deadlocked\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003061 }
3062
Emilian Peevbd8c5032018-02-14 23:05:40 +00003063 int argSize = args.size();
3064 for (int i = 0; i < argSize; i++) {
3065 if (args[i] == TagMonitor::kMonitorOption) {
3066 if (i + 1 < argSize) {
3067 mMonitorTags = String8(args[i + 1]);
3068 }
3069 break;
3070 }
3071 }
3072
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003073 for (auto& state : mCameraStates) {
3074 String8 cameraId = state.first;
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003075
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003076 dprintf(fd, "== Camera device %s dynamic info: ==\n", cameraId.string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003077
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003078 CameraParameters p = state.second->getShimParams();
3079 if (!p.isEmpty()) {
3080 dprintf(fd, " Camera1 API shim is using parameters:\n ");
3081 p.dump(fd, args);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003082 }
3083
3084 auto clientDescriptor = mActiveClientManager.get(cameraId);
Zhijun He2f140ed2017-02-08 09:57:23 -08003085 if (clientDescriptor != nullptr) {
3086 dprintf(fd, " Device %s is open. Client instance dump:\n",
3087 cameraId.string());
3088 dprintf(fd, " Client priority score: %d state: %d\n",
3089 clientDescriptor->getPriority().getScore(),
3090 clientDescriptor->getPriority().getState());
3091 dprintf(fd, " Client PID: %d\n", clientDescriptor->getOwnerId());
3092
3093 auto client = clientDescriptor->getValue();
3094 dprintf(fd, " Client package: %s\n",
3095 String8(client->getPackageName()).string());
3096
3097 client->dumpClient(fd, args);
3098 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003099 dprintf(fd, " Device %s is closed, no client instance\n",
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003100 cameraId.string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003101 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003102
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003103 }
3104
3105 if (stateLocked) mCameraStatesLock.unlock();
3106
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003107 if (locked) mServiceLock.unlock();
3108
Emilian Peevf53f66e2017-04-11 14:29:43 +01003109 mCameraProviderManager->dump(fd, args);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003110
3111 dprintf(fd, "\n== Vendor tags: ==\n\n");
3112
3113 sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
3114 if (desc == NULL) {
Emilian Peev71c73a22017-03-21 16:35:51 +00003115 sp<VendorTagDescriptorCache> cache =
3116 VendorTagDescriptorCache::getGlobalVendorTagCache();
3117 if (cache == NULL) {
3118 dprintf(fd, "No vendor tags.\n");
3119 } else {
3120 cache->dump(fd, /*verbosity*/2, /*indentation*/2);
3121 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003122 } else {
3123 desc->dump(fd, /*verbosity*/2, /*indentation*/2);
3124 }
3125
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003126 // Dump camera traces if there were any
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003127 dprintf(fd, "\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003128 camera3::CameraTraces::dump(fd, args);
3129
3130 // Process dump arguments, if any
3131 int n = args.size();
3132 String16 verboseOption("-v");
3133 String16 unreachableOption("--unreachable");
3134 for (int i = 0; i < n; i++) {
3135 if (args[i] == verboseOption) {
3136 // change logging level
3137 if (i + 1 >= n) continue;
3138 String8 levelStr(args[i+1]);
3139 int level = atoi(levelStr.string());
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003140 dprintf(fd, "\nSetting log level to %d.\n", level);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003141 setLogLevel(level);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003142 } else if (args[i] == unreachableOption) {
3143 // Dump memory analysis
3144 // TODO - should limit be an argument parameter?
3145 UnreachableMemoryInfo info;
3146 bool success = GetUnreachableMemory(info, /*limit*/ 10000);
3147 if (!success) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003148 dprintf(fd, "\n== Unable to dump unreachable memory. "
3149 "Try disabling SELinux enforcement. ==\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003150 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003151 dprintf(fd, "\n== Dumping unreachable memory: ==\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08003152 std::string s = info.ToString(/*log_contents*/ true);
3153 write(fd, s.c_str(), s.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07003154 }
3155 }
3156 }
3157 return NO_ERROR;
3158}
3159
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003160void CameraService::dumpEventLog(int fd) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003161 dprintf(fd, "\n== Camera service events log (most recent at top): ==\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003162
3163 Mutex::Autolock l(mLogLock);
3164 for (const auto& msg : mEventLog) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003165 dprintf(fd, " %s\n", msg.string());
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003166 }
3167
3168 if (mEventLog.size() == DEFAULT_EVENT_LOG_LENGTH) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003169 dprintf(fd, " ...\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003170 } else if (mEventLog.size() == 0) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003171 dprintf(fd, " [no events yet]\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003172 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08003173 dprintf(fd, "\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07003174}
3175
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003176void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003177 Mutex::Autolock al(mTorchClientMapMutex);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003178 for (size_t i = 0; i < mTorchClientMap.size(); i++) {
3179 if (mTorchClientMap[i] == who) {
3180 // turn off the torch mode that was turned on by dead client
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003181 String8 cameraId = mTorchClientMap.keyAt(i);
3182 status_t res = mFlashlight->setTorchMode(cameraId, false);
3183 if (res) {
3184 ALOGE("%s: torch client died but couldn't turn off torch: "
3185 "%s (%d)", __FUNCTION__, strerror(-res), res);
3186 return;
3187 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003188 mTorchClientMap.removeItemsAt(i);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003189 break;
3190 }
3191 }
3192}
3193
Ruben Brunkcc776712015-02-17 20:18:47 -08003194/*virtual*/void CameraService::binderDied(const wp<IBinder> &who) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07003195
Igor Murashkin294d0ec2012-10-05 10:44:57 -07003196 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07003197 * While tempting to promote the wp<IBinder> into a sp, it's actually not supported by the
3198 * binder driver
Igor Murashkin294d0ec2012-10-05 10:44:57 -07003199 */
Yin-Chia Yehdbfcb382018-02-16 11:17:36 -08003200 // PID here is approximate and can be wrong.
Jayant Chowdhary12361932018-08-27 14:46:13 -07003201 logClientDied(CameraThreadState::getCallingPid(), String8("Binder died unexpectedly"));
Ruben Brunka8ca9152015-04-07 14:23:40 -07003202
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003203 // check torch client
3204 handleTorchClientBinderDied(who);
3205
3206 // check camera device client
Ruben Brunkcc776712015-02-17 20:18:47 -08003207 if(!evictClientIdByRemote(who)) {
3208 ALOGV("%s: Java client's binder death already cleaned up (normal case)", __FUNCTION__);
Igor Murashkinecf17e82012-10-02 16:05:11 -07003209 return;
3210 }
3211
Ruben Brunkcc776712015-02-17 20:18:47 -08003212 ALOGE("%s: Java client's binder died, removing it from the list of active clients",
3213 __FUNCTION__);
Igor Murashkinecf17e82012-10-02 16:05:11 -07003214}
3215
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003216void CameraService::updateStatus(StatusInternal status, const String8& cameraId) {
Ruben Brunkcc776712015-02-17 20:18:47 -08003217 updateStatus(status, cameraId, {});
Igor Murashkinbfc99152013-02-27 12:55:20 -08003218}
3219
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003220void CameraService::updateStatus(StatusInternal status, const String8& cameraId,
3221 std::initializer_list<StatusInternal> rejectSourceStates) {
Ruben Brunkcc776712015-02-17 20:18:47 -08003222 // Do not lock mServiceLock here or can get into a deadlock from
3223 // connect() -> disconnect -> updateStatus
3224
3225 auto state = getCameraState(cameraId);
3226
3227 if (state == nullptr) {
3228 ALOGW("%s: Could not update the status for %s, no such device exists", __FUNCTION__,
3229 cameraId.string());
3230 return;
Igor Murashkincba2c162013-03-20 15:56:31 -07003231 }
3232
Ruben Brunkcc776712015-02-17 20:18:47 -08003233 // Update the status for this camera state, then send the onStatusChangedCallbacks to each
3234 // of the listeners with both the mStatusStatus and mStatusListenerLock held
3235 state->updateStatus(status, cameraId, rejectSourceStates, [this]
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003236 (const String8& cameraId, StatusInternal status) {
Ruben Brunkcc776712015-02-17 20:18:47 -08003237
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003238 if (status != StatusInternal::ENUMERATING) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07003239 // Update torch status if it has a flash unit.
3240 Mutex::Autolock al(mTorchStatusMutex);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003241 TorchModeStatus torchStatus;
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07003242 if (getTorchStatusLocked(cameraId, &torchStatus) !=
3243 NAME_NOT_FOUND) {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003244 TorchModeStatus newTorchStatus =
3245 status == StatusInternal::PRESENT ?
3246 TorchModeStatus::AVAILABLE_OFF :
3247 TorchModeStatus::NOT_AVAILABLE;
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07003248 if (torchStatus != newTorchStatus) {
3249 onTorchStatusChangedLocked(cameraId, newTorchStatus);
3250 }
3251 }
Ruben Brunkcc776712015-02-17 20:18:47 -08003252 }
3253
3254 Mutex::Autolock lock(mStatusListenerLock);
3255
3256 for (auto& listener : mListenerList) {
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08003257 if (!listener.first &&
3258 mCameraProviderManager->isPublicallyHiddenSecureCamera(cameraId.c_str())) {
3259 ALOGV("Skipping camera discovery callback for system-only camera %s",
3260 cameraId.c_str());
3261 continue;
3262 }
Emilian Peev53722fa2019-02-22 17:47:20 -08003263 listener.second->getListener()->onStatusChanged(mapToInterface(status),
3264 String16(cameraId));
Ruben Brunkcc776712015-02-17 20:18:47 -08003265 }
3266 });
Igor Murashkincba2c162013-03-20 15:56:31 -07003267}
3268
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003269template<class Func>
3270void CameraService::CameraState::updateStatus(StatusInternal status,
3271 const String8& cameraId,
3272 std::initializer_list<StatusInternal> rejectSourceStates,
3273 Func onStatusUpdatedLocked) {
3274 Mutex::Autolock lock(mStatusLock);
3275 StatusInternal oldStatus = mStatus;
3276 mStatus = status;
3277
3278 if (oldStatus == status) {
3279 return;
3280 }
3281
3282 ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
3283 cameraId.string(), oldStatus, status);
3284
3285 if (oldStatus == StatusInternal::NOT_PRESENT &&
3286 (status != StatusInternal::PRESENT &&
3287 status != StatusInternal::ENUMERATING)) {
3288
3289 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
3290 __FUNCTION__);
3291 mStatus = oldStatus;
3292 return;
3293 }
3294
3295 /**
3296 * Sometimes we want to conditionally do a transition.
3297 * For example if a client disconnects, we want to go to PRESENT
3298 * only if we weren't already in NOT_PRESENT or ENUMERATING.
3299 */
3300 for (auto& rejectStatus : rejectSourceStates) {
3301 if (oldStatus == rejectStatus) {
3302 ALOGV("%s: Rejecting status transition for Camera ID %s, since the source "
3303 "state was was in one of the bad states.", __FUNCTION__, cameraId.string());
3304 mStatus = oldStatus;
3305 return;
3306 }
3307 }
3308
3309 onStatusUpdatedLocked(cameraId, status);
3310}
3311
Eino-Ville Talvalae8c96c72017-06-27 12:24:07 -07003312void CameraService::updateProxyDeviceState(int newState,
Emilian Peev573291c2018-02-10 02:10:56 +00003313 const String8& cameraId, int facing, const String16& clientName, int apiLevel) {
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07003314 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
3315 if (proxyBinder == nullptr) return;
3316 String16 id(cameraId);
Emilian Peev573291c2018-02-10 02:10:56 +00003317 proxyBinder->notifyCameraState(id, newState, facing, clientName, apiLevel);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07003318}
3319
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003320status_t CameraService::getTorchStatusLocked(
3321 const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003322 TorchModeStatus *status) const {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003323 if (!status) {
3324 return BAD_VALUE;
3325 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003326 ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3327 if (index == NAME_NOT_FOUND) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003328 // invalid camera ID or the camera doesn't have a flash unit
3329 return NAME_NOT_FOUND;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003330 }
3331
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003332 *status = mTorchStatusMap.valueAt(index);
3333 return OK;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003334}
3335
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003336status_t CameraService::setTorchStatusLocked(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003337 TorchModeStatus status) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003338 ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3339 if (index == NAME_NOT_FOUND) {
3340 return BAD_VALUE;
3341 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003342 mTorchStatusMap.editValueAt(index) = status;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003343
3344 return OK;
3345}
3346
Svet Ganova453d0d2018-01-11 15:37:58 -08003347void CameraService::blockClientsForUid(uid_t uid) {
3348 const auto clients = mActiveClientManager.getAll();
3349 for (auto& current : clients) {
3350 if (current != nullptr) {
3351 const auto basicClient = current->getValue();
3352 if (basicClient.get() != nullptr && basicClient->getClientUid() == uid) {
3353 basicClient->block();
3354 }
3355 }
3356 }
3357}
3358
Michael Grooverd1d435a2018-12-18 17:39:42 -08003359void CameraService::blockAllClients() {
3360 const auto clients = mActiveClientManager.getAll();
3361 for (auto& current : clients) {
3362 if (current != nullptr) {
3363 const auto basicClient = current->getValue();
3364 if (basicClient.get() != nullptr) {
3365 basicClient->block();
3366 }
3367 }
3368 }
3369}
3370
Svet Ganova453d0d2018-01-11 15:37:58 -08003371// NOTE: This is a remote API - make sure all args are validated
3372status_t CameraService::shellCommand(int in, int out, int err, const Vector<String16>& args) {
3373 if (!checkCallingPermission(sManageCameraPermission, nullptr, nullptr)) {
3374 return PERMISSION_DENIED;
3375 }
3376 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
3377 return BAD_VALUE;
3378 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003379 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003380 return handleSetUidState(args, err);
Nicholas Sauera3620332019-04-03 14:05:17 -07003381 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003382 return handleResetUidState(args, err);
Nicholas Sauera3620332019-04-03 14:05:17 -07003383 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003384 return handleGetUidState(args, out, err);
3385 } else if (args.size() == 1 && args[0] == String16("help")) {
3386 printHelp(out);
3387 return NO_ERROR;
3388 }
3389 printHelp(err);
3390 return BAD_VALUE;
3391}
3392
3393status_t CameraService::handleSetUidState(const Vector<String16>& args, int err) {
Nicholas Sauera3620332019-04-03 14:05:17 -07003394 String16 packageName = args[1];
3395
Svet Ganova453d0d2018-01-11 15:37:58 -08003396 bool active = false;
3397 if (args[2] == String16("active")) {
3398 active = true;
3399 } else if ((args[2] != String16("idle"))) {
3400 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
3401 return BAD_VALUE;
3402 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003403
3404 int userId = 0;
3405 if (args.size() >= 5 && args[3] == String16("--user")) {
3406 userId = atoi(String8(args[4]));
3407 }
3408
3409 uid_t uid;
3410 if (getUidForPackage(packageName, userId, uid, err) == BAD_VALUE) {
3411 return BAD_VALUE;
3412 }
3413
3414 mUidPolicy->addOverrideUid(uid, packageName, active);
Svet Ganova453d0d2018-01-11 15:37:58 -08003415 return NO_ERROR;
3416}
3417
3418status_t CameraService::handleResetUidState(const Vector<String16>& args, int err) {
Nicholas Sauera3620332019-04-03 14:05:17 -07003419 String16 packageName = args[1];
3420
3421 int userId = 0;
3422 if (args.size() >= 4 && args[2] == String16("--user")) {
3423 userId = atoi(String8(args[3]));
3424 }
3425
3426 uid_t uid;
3427 if (getUidForPackage(packageName, userId, uid, err) == BAD_VALUE) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003428 return BAD_VALUE;
3429 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003430
3431 mUidPolicy->removeOverrideUid(uid, packageName);
Svet Ganova453d0d2018-01-11 15:37:58 -08003432 return NO_ERROR;
3433}
3434
3435status_t CameraService::handleGetUidState(const Vector<String16>& args, int out, int err) {
Nicholas Sauera3620332019-04-03 14:05:17 -07003436 String16 packageName = args[1];
3437
3438 int userId = 0;
3439 if (args.size() >= 4 && args[2] == String16("--user")) {
3440 userId = atoi(String8(args[3]));
3441 }
3442
3443 uid_t uid;
3444 if (getUidForPackage(packageName, userId, uid, err) == BAD_VALUE) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003445 return BAD_VALUE;
3446 }
Nicholas Sauera3620332019-04-03 14:05:17 -07003447
3448 if (mUidPolicy->isUidActive(uid, packageName)) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003449 return dprintf(out, "active\n");
3450 } else {
3451 return dprintf(out, "idle\n");
3452 }
3453}
3454
3455status_t CameraService::printHelp(int out) {
3456 return dprintf(out, "Camera service commands:\n"
Nicholas Sauera3620332019-04-03 14:05:17 -07003457 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
3458 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
3459 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganova453d0d2018-01-11 15:37:58 -08003460 " help print this message\n");
3461}
3462
Mathias Agopian65ab4712010-07-14 17:59:35 -07003463}; // namespace android