blob: 6003607600f82f40e3930160dc09e241e6898a85 [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>
Eino-Ville Talvalad89821e2016-04-20 11:23:50 -070052#include <memunreachable/memunreachable.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070053#include <media/AudioSystem.h>
Andreas Huber1b86fe02014-01-29 11:13:26 -080054#include <media/IMediaHTTPService.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070055#include <media/mediaplayer.h>
Ruben Brunk99e69712015-05-26 17:25:07 -070056#include <mediautils/BatteryNotifier.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070057#include <utils/Errors.h>
58#include <utils/Log.h>
59#include <utils/String16.h>
Svet Ganov94ec46f2018-06-08 15:03:46 -070060#include <utils/SystemClock.h>
Ruben Brunkd1176ef2014-02-21 10:51:38 -080061#include <utils/Trace.h>
Chien-Yu Chen98a668f2015-12-18 14:10:33 -080062#include <private/android_filesystem_config.h>
Ruben Brunkd1176ef2014-02-21 10:51:38 -080063#include <system/camera_vendor_tags.h>
Ruben Brunkb2119af2014-05-09 19:57:56 -070064#include <system/camera_metadata.h>
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080065
Ruben Brunkb2119af2014-05-09 19:57:56 -070066#include <system/camera.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070067
68#include "CameraService.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070069#include "api1/CameraClient.h"
70#include "api1/Camera2Client.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070071#include "api2/CameraDeviceClient.h"
Igor Murashkinff3e31d2013-10-23 16:40:06 -070072#include "utils/CameraTraces.h"
Emilian Peevbd8c5032018-02-14 23:05:40 +000073#include "utils/TagMonitor.h"
Jayant Chowdhary12361932018-08-27 14:46:13 -070074#include "utils/CameraThreadState.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070075
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -080076namespace {
77 const char* kPermissionServiceName = "permission";
78}; // namespace anonymous
79
Mathias Agopian65ab4712010-07-14 17:59:35 -070080namespace android {
81
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080082using binder::Status;
Jayant Chowdharybe543d42018-08-15 13:16:14 -070083using frameworks::cameraservice::service::V2_0::implementation::HidlCameraService;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -080084using hardware::ICamera;
85using hardware::ICameraClient;
Eino-Ville Talvalae8c96c72017-06-27 12:24:07 -070086using hardware::ICameraServiceProxy;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -080087using hardware::ICameraServiceListener;
88using hardware::camera::common::V1_0::CameraDeviceStatus;
89using hardware::camera::common::V1_0::TorchModeStatus;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080090
Mathias Agopian65ab4712010-07-14 17:59:35 -070091// ----------------------------------------------------------------------------
92// Logging support -- this is for debugging only
93// Use "adb shell dumpsys media.camera -v 1" to change it.
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -070094volatile int32_t gLogLevel = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -070095
Steve Blockb8a80522011-12-20 16:23:08 +000096#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
97#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
Mathias Agopian65ab4712010-07-14 17:59:35 -070098
99static void setLogLevel(int level) {
100 android_atomic_write(level, &gLogLevel);
101}
102
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800103// Convenience methods for constructing binder::Status objects for error returns
104
105#define STATUS_ERROR(errorCode, errorString) \
106 binder::Status::fromServiceSpecificError(errorCode, \
107 String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString))
108
109#define STATUS_ERROR_FMT(errorCode, errorString, ...) \
110 binder::Status::fromServiceSpecificError(errorCode, \
111 String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, \
112 __VA_ARGS__))
113
Mathias Agopian65ab4712010-07-14 17:59:35 -0700114// ----------------------------------------------------------------------------
115
Svet Ganova453d0d2018-01-11 15:37:58 -0800116static const String16 sManageCameraPermission("android.permission.MANAGE_CAMERA");
117
Eino-Ville Talvala49c97052016-01-12 14:29:40 -0800118CameraService::CameraService() :
119 mEventLog(DEFAULT_EVENT_LOG_LENGTH),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800120 mNumberOfCameras(0),
Emilian Peevf53f66e2017-04-11 14:29:43 +0100121 mSoundRef(0), mInitialized(false) {
Steve Blockdf64d152012-01-04 20:05:49 +0000122 ALOGI("CameraService started (pid=%d)", getpid());
Ruben Brunkcc776712015-02-17 20:18:47 -0800123 mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700124}
125
Iliyan Malchev8951a972011-04-14 16:55:59 -0700126void CameraService::onFirstRef()
127{
Ruben Brunkcc776712015-02-17 20:18:47 -0800128 ALOGI("CameraService process starting");
Igor Murashkin634a5152013-02-20 17:15:11 -0800129
Iliyan Malchev8951a972011-04-14 16:55:59 -0700130 BnCameraService::onFirstRef();
131
Ruben Brunk99e69712015-05-26 17:25:07 -0700132 // Update battery life tracking if service is restarting
133 BatteryNotifier& notifier(BatteryNotifier::getInstance());
134 notifier.noteResetCamera();
135 notifier.noteResetFlashlight();
136
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800137 status_t res = INVALID_OPERATION;
Eino-Ville Talvala9cbbc832017-01-23 15:39:53 -0800138
Emilian Peevf53f66e2017-04-11 14:29:43 +0100139 res = enumerateProviders();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800140 if (res == OK) {
141 mInitialized = true;
142 }
143
144 CameraService::pingCameraServiceProxy();
Svet Ganova453d0d2018-01-11 15:37:58 -0800145
146 mUidPolicy = new UidPolicy(this);
147 mUidPolicy->registerSelf();
Jayant Chowdharybe543d42018-08-15 13:16:14 -0700148 sp<HidlCameraService> hcs = HidlCameraService::getInstance(this);
149 if (hcs->registerAsService() != android::OK) {
150 ALOGE("%s: Failed to register default android.frameworks.cameraservice.service@1.0",
151 __FUNCTION__);
152 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800153}
154
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800155status_t CameraService::enumerateProviders() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800156 status_t res;
Emilian Peevaee727d2017-05-04 16:35:48 +0100157
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800158 std::vector<std::string> deviceIds;
159 {
160 Mutex::Autolock l(mServiceLock);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800161
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800162 if (nullptr == mCameraProviderManager.get()) {
163 mCameraProviderManager = new CameraProviderManager();
164 res = mCameraProviderManager->initialize(this);
165 if (res != OK) {
166 ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
167 __FUNCTION__, strerror(-res), res);
168 return res;
Emilian Peevaee727d2017-05-04 16:35:48 +0100169 }
170 }
171
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800172
173 // Setup vendor tags before we call get_camera_info the first time
174 // because HAL might need to setup static vendor keys in get_camera_info
175 // TODO: maybe put this into CameraProviderManager::initialize()?
176 mCameraProviderManager->setUpVendorTags();
177
178 if (nullptr == mFlashlight.get()) {
179 mFlashlight = new CameraFlashlight(mCameraProviderManager, this);
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700180 }
181
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800182 res = mFlashlight->findFlashUnits();
183 if (res != OK) {
184 ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);
185 }
186
187 deviceIds = mCameraProviderManager->getCameraDeviceIds();
188 }
189
190
191 for (auto& cameraId : deviceIds) {
192 String8 id8 = String8(cameraId.c_str());
Shuzhen Wang6ba3f5e2018-11-20 10:04:08 -0800193 if (getCameraState(id8) == nullptr) {
194 onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);
195 }
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800196 }
197
198 return OK;
199}
200
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700201sp<ICameraServiceProxy> CameraService::getCameraServiceProxy() {
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800202 sp<ICameraServiceProxy> proxyBinder = nullptr;
203#ifndef __BRILLO__
Ruben Brunk2823ce02015-05-19 17:25:13 -0700204 sp<IServiceManager> sm = defaultServiceManager();
Eino-Ville Talvalaf4db13d2016-12-08 11:20:51 -0800205 // Use checkService because cameraserver normally starts before the
206 // system server and the proxy service. So the long timeout that getService
207 // has before giving up is inappropriate.
208 sp<IBinder> binder = sm->checkService(String16("media.camera.proxy"));
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800209 if (binder != nullptr) {
210 proxyBinder = interface_cast<ICameraServiceProxy>(binder);
Ruben Brunk2823ce02015-05-19 17:25:13 -0700211 }
Christopher Wiley92c06fc2016-02-11 15:40:05 -0800212#endif
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700213 return proxyBinder;
214}
215
216void CameraService::pingCameraServiceProxy() {
217 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
218 if (proxyBinder == nullptr) return;
Ruben Brunk2823ce02015-05-19 17:25:13 -0700219 proxyBinder->pingForUserUpdate();
Iliyan Malchev8951a972011-04-14 16:55:59 -0700220}
221
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800222void CameraService::broadcastTorchModeStatus(const String8& cameraId, TorchModeStatus status) {
223 Mutex::Autolock lock(mStatusListenerLock);
224
225 for (auto& i : mListenerList) {
226 i->onTorchStatusChanged(mapToInterface(status), String16{cameraId});
227 }
228}
229
Mathias Agopian65ab4712010-07-14 17:59:35 -0700230CameraService::~CameraService() {
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800231 VendorTagDescriptor::clearGlobalVendorTagDescriptor();
Svet Ganova453d0d2018-01-11 15:37:58 -0800232 mUidPolicy->unregisterSelf();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700233}
234
Emilian Peevaee727d2017-05-04 16:35:48 +0100235void CameraService::onNewProviderRegistered() {
236 enumerateProviders();
237}
238
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800239void CameraService::updateCameraNumAndIds() {
240 Mutex::Autolock l(mServiceLock);
241 mNumberOfCameras = mCameraProviderManager->getCameraCount();
242 mNormalDeviceIds =
243 mCameraProviderManager->getAPI1CompatibleCameraDeviceIds();
244}
245
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100246void CameraService::addStates(const String8 id) {
247 std::string cameraId(id.c_str());
248 hardware::camera::common::V1_0::CameraResourceCost cost;
249 status_t res = mCameraProviderManager->getResourceCost(cameraId, &cost);
250 if (res != OK) {
251 ALOGE("Failed to query device resource cost: %s (%d)", strerror(-res), res);
252 return;
253 }
254 std::set<String8> conflicting;
255 for (size_t i = 0; i < cost.conflictingDevices.size(); i++) {
256 conflicting.emplace(String8(cost.conflictingDevices[i].c_str()));
257 }
258
259 {
260 Mutex::Autolock lock(mCameraStatesLock);
261 mCameraStates.emplace(id, std::make_shared<CameraState>(id, cost.resourceCost,
262 conflicting));
263 }
264
265 if (mFlashlight->hasFlashUnit(id)) {
Emilian Peev7f25e5f2018-04-11 16:50:34 +0100266 Mutex::Autolock al(mTorchStatusMutex);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100267 mTorchStatusMap.add(id, TorchModeStatus::AVAILABLE_OFF);
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800268
269 broadcastTorchModeStatus(id, TorchModeStatus::AVAILABLE_OFF);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100270 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800271
272 updateCameraNumAndIds();
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100273 logDeviceAdded(id, "Device added");
274}
275
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100276void CameraService::removeStates(const String8 id) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800277 updateCameraNumAndIds();
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100278 if (mFlashlight->hasFlashUnit(id)) {
Emilian Peev7f25e5f2018-04-11 16:50:34 +0100279 Mutex::Autolock al(mTorchStatusMutex);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100280 mTorchStatusMap.removeItem(id);
281 }
282
283 {
284 Mutex::Autolock lock(mCameraStatesLock);
285 mCameraStates.erase(id);
286 }
287}
288
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800289void CameraService::onDeviceStatusChanged(const String8& id,
290 CameraDeviceStatus newHalStatus) {
291 ALOGI("%s: Status changed for cameraId=%s, newStatus=%d", __FUNCTION__,
292 id.string(), newHalStatus);
Igor Murashkincba2c162013-03-20 15:56:31 -0700293
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800294 StatusInternal newStatus = mapToInternal(newHalStatus);
295
Ruben Brunkcc776712015-02-17 20:18:47 -0800296 std::shared_ptr<CameraState> state = getCameraState(id);
297
298 if (state == nullptr) {
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700299 if (newStatus == StatusInternal::PRESENT) {
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100300 ALOGI("%s: Unknown camera ID %s, a new camera is added",
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700301 __FUNCTION__, id.string());
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100302
303 // First add as absent to make sure clients are notified below
304 addStates(id);
305
306 updateStatus(newStatus, id);
Yin-Chia Yeh92e33212017-05-24 15:54:15 -0700307 } else {
308 ALOGE("%s: Bad camera ID %s", __FUNCTION__, id.string());
309 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700310 return;
311 }
312
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800313 StatusInternal oldStatus = state->getStatus();
Ruben Brunkcc776712015-02-17 20:18:47 -0800314
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800315 if (oldStatus == newStatus) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800316 ALOGE("%s: State transition to the same status %#x not allowed", __FUNCTION__, newStatus);
Igor Murashkincba2c162013-03-20 15:56:31 -0700317 return;
318 }
319
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800320 if (newStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunka8ca9152015-04-07 14:23:40 -0700321 logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus,
322 newStatus));
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800323
324 // Set the device status to NOT_PRESENT, clients will no longer be able to connect
325 // to this device until the status changes
326 updateStatus(StatusInternal::NOT_PRESENT, id);
327
Ruben Brunkcc776712015-02-17 20:18:47 -0800328 sp<BasicClient> clientToDisconnect;
Igor Murashkincba2c162013-03-20 15:56:31 -0700329 {
Ruben Brunkcc776712015-02-17 20:18:47 -0800330 // Don't do this in updateStatus to avoid deadlock over mServiceLock
331 Mutex::Autolock lock(mServiceLock);
Igor Murashkincba2c162013-03-20 15:56:31 -0700332
Ruben Brunkcc776712015-02-17 20:18:47 -0800333 // Remove cached shim parameters
334 state->setShimParams(CameraParameters());
Igor Murashkincba2c162013-03-20 15:56:31 -0700335
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700336 // Remove the client from the list of active clients, if there is one
Ruben Brunkcc776712015-02-17 20:18:47 -0800337 clientToDisconnect = removeClientLocked(id);
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700338 }
Ruben Brunkcc776712015-02-17 20:18:47 -0800339
Eino-Ville Talvala8d942f92017-03-13 10:09:51 -0700340 // Disconnect client
341 if (clientToDisconnect.get() != nullptr) {
342 ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL",
343 __FUNCTION__, id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -0800344 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800345 clientToDisconnect->notifyError(
346 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -0800347 CaptureResultExtras{});
Ruben Brunkcc776712015-02-17 20:18:47 -0800348 // Ensure not in binder RPC so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -0700349 LOG_ALWAYS_FATAL_IF(CameraThreadState::getCallingPid() != getpid(),
Ruben Brunkcc776712015-02-17 20:18:47 -0800350 "onDeviceStatusChanged must be called from the camera service process!");
351 clientToDisconnect->disconnect();
Igor Murashkincba2c162013-03-20 15:56:31 -0700352 }
353
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100354 removeStates(id);
Ruben Brunkcc776712015-02-17 20:18:47 -0800355 } else {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800356 if (oldStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunka8ca9152015-04-07 14:23:40 -0700357 logDeviceAdded(id, String8::format("Device status changed from %d to %d", oldStatus,
358 newStatus));
359 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800360 updateStatus(newStatus, id);
Igor Murashkincba2c162013-03-20 15:56:31 -0700361 }
362
Igor Murashkincba2c162013-03-20 15:56:31 -0700363}
364
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800365void CameraService::onTorchStatusChanged(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800366 TorchModeStatus newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800367 Mutex::Autolock al(mTorchStatusMutex);
368 onTorchStatusChangedLocked(cameraId, newStatus);
369}
370
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800371void CameraService::onTorchStatusChangedLocked(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800372 TorchModeStatus newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800373 ALOGI("%s: Torch status changed for cameraId=%s, newStatus=%d",
374 __FUNCTION__, cameraId.string(), newStatus);
375
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800376 TorchModeStatus status;
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800377 status_t res = getTorchStatusLocked(cameraId, &status);
378 if (res) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -0700379 ALOGE("%s: cannot get torch status of camera %s: %s (%d)",
380 __FUNCTION__, cameraId.string(), strerror(-res), res);
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800381 return;
382 }
383 if (status == newStatus) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800384 return;
385 }
386
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800387 res = setTorchStatusLocked(cameraId, newStatus);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800388 if (res) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800389 ALOGE("%s: Failed to set the torch status to %d: %s (%d)", __FUNCTION__,
390 (uint32_t)newStatus, strerror(-res), res);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800391 return;
392 }
393
Ruben Brunkcc776712015-02-17 20:18:47 -0800394 {
Ruben Brunk99e69712015-05-26 17:25:07 -0700395 // Update battery life logging for flashlight
Chien-Yu Chenfe751be2015-09-01 14:16:44 -0700396 Mutex::Autolock al(mTorchUidMapMutex);
Ruben Brunk99e69712015-05-26 17:25:07 -0700397 auto iter = mTorchUidMap.find(cameraId);
398 if (iter != mTorchUidMap.end()) {
399 int oldUid = iter->second.second;
400 int newUid = iter->second.first;
401 BatteryNotifier& notifier(BatteryNotifier::getInstance());
402 if (oldUid != newUid) {
403 // If the UID has changed, log the status and update current UID in mTorchUidMap
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800404 if (status == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700405 notifier.noteFlashlightOff(cameraId, oldUid);
406 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800407 if (newStatus == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700408 notifier.noteFlashlightOn(cameraId, newUid);
409 }
410 iter->second.second = newUid;
411 } else {
412 // If the UID has not changed, log the status
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800413 if (newStatus == TorchModeStatus::AVAILABLE_ON) {
Ruben Brunk99e69712015-05-26 17:25:07 -0700414 notifier.noteFlashlightOn(cameraId, oldUid);
415 } else {
416 notifier.noteFlashlightOff(cameraId, oldUid);
417 }
418 }
419 }
420 }
421
Shuzhen Wang7d859d42018-11-06 15:33:23 -0800422 broadcastTorchModeStatus(cameraId, newStatus);
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800423}
424
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800425Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700426 ATRACE_CALL();
Emilian Peevaee727d2017-05-04 16:35:48 +0100427 Mutex::Autolock l(mServiceLock);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700428 switch (type) {
429 case CAMERA_TYPE_BACKWARD_COMPATIBLE:
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800430 *numCameras = static_cast<int>(mNormalDeviceIds.size());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800431 break;
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700432 case CAMERA_TYPE_ALL:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800433 *numCameras = mNumberOfCameras;
434 break;
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700435 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800436 ALOGW("%s: Unknown camera type %d",
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700437 __FUNCTION__, type);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800438 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
439 "Unknown camera type %d", type);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700440 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800441 return Status::ok();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700442}
443
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800444Status CameraService::getCameraInfo(int cameraId,
445 CameraInfo* cameraInfo) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700446 ATRACE_CALL();
Emilian Peevaee727d2017-05-04 16:35:48 +0100447 Mutex::Autolock l(mServiceLock);
448
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800449 if (!mInitialized) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800450 return STATUS_ERROR(ERROR_DISCONNECTED,
451 "Camera subsystem is not available");
Iliyan Malchev8951a972011-04-14 16:55:59 -0700452 }
453
Mathias Agopian65ab4712010-07-14 17:59:35 -0700454 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800455 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
456 "CameraId is not valid");
Mathias Agopian65ab4712010-07-14 17:59:35 -0700457 }
458
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800459 Status ret = Status::ok();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800460 status_t err = mCameraProviderManager->getCameraInfo(
461 cameraIdIntToStrLocked(cameraId), cameraInfo);
Emilian Peevf53f66e2017-04-11 14:29:43 +0100462 if (err != OK) {
463 ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
464 "Error retrieving camera info from device %d: %s (%d)", cameraId,
465 strerror(-err), err);
Ruben Brunkcc776712015-02-17 20:18:47 -0800466 }
Emilian Peevf53f66e2017-04-11 14:29:43 +0100467
Ruben Brunkcc776712015-02-17 20:18:47 -0800468 return ret;
469}
Ruben Brunkb2119af2014-05-09 19:57:56 -0700470
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800471std::string CameraService::cameraIdIntToStrLocked(int cameraIdInt) {
472 if (cameraIdInt < 0 || cameraIdInt >= static_cast<int>(mNormalDeviceIds.size())) {
473 ALOGE("%s: input id %d invalid: valid range (0, %zu)",
474 __FUNCTION__, cameraIdInt, mNormalDeviceIds.size());
475 return std::string{};
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800476 }
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800477
478 return mNormalDeviceIds[cameraIdInt];
479}
480
481String8 CameraService::cameraIdIntToStr(int cameraIdInt) {
482 Mutex::Autolock lock(mServiceLock);
483 return String8(cameraIdIntToStrLocked(cameraIdInt).c_str());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800484}
485
486Status CameraService::getCameraCharacteristics(const String16& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800487 CameraMetadata* cameraInfo) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700488 ATRACE_CALL();
Zhijun He2b59be82013-09-25 10:14:30 -0700489 if (!cameraInfo) {
490 ALOGE("%s: cameraInfo is NULL", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800491 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "cameraInfo is NULL");
Zhijun He2b59be82013-09-25 10:14:30 -0700492 }
493
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800494 if (!mInitialized) {
495 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800496 return STATUS_ERROR(ERROR_DISCONNECTED,
497 "Camera subsystem is not available");;
Zhijun He2b59be82013-09-25 10:14:30 -0700498 }
499
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800500 Status ret{};
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800501
Emilian Peevf53f66e2017-04-11 14:29:43 +0100502 status_t res = mCameraProviderManager->getCameraCharacteristics(
503 String8(cameraId).string(), cameraInfo);
504 if (res != OK) {
505 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Unable to retrieve camera "
506 "characteristics for device %s: %s (%d)", String8(cameraId).string(),
507 strerror(-res), res);
Ruben Brunkb2119af2014-05-09 19:57:56 -0700508 }
Zhijun He2b59be82013-09-25 10:14:30 -0700509
Jayant Chowdhary12361932018-08-27 14:46:13 -0700510 int callingPid = CameraThreadState::getCallingPid();
511 int callingUid = CameraThreadState::getCallingUid();
Emilian Peeve20c6372018-08-14 18:45:53 +0100512 std::vector<int32_t> tagsRemoved;
513 // If it's not calling from cameraserver, check the permission.
514 if ((callingPid != getpid()) &&
515 !checkPermission(String16("android.permission.CAMERA"), callingPid, callingUid)) {
516 res = cameraInfo->removePermissionEntries(
517 mCameraProviderManager->getProviderTagIdLocked(String8(cameraId).string()),
518 &tagsRemoved);
519 if (res != OK) {
520 cameraInfo->clear();
521 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to remove camera"
522 " characteristics needing camera permission for device %s: %s (%d)",
523 String8(cameraId).string(), strerror(-res), res);
524 }
525 }
526
527 if (!tagsRemoved.empty()) {
528 res = cameraInfo->update(ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION,
529 tagsRemoved.data(), tagsRemoved.size());
530 if (res != OK) {
531 cameraInfo->clear();
532 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to insert camera "
533 "keys needing permission for device %s: %s (%d)", String8(cameraId).string(),
534 strerror(-res), res);
535 }
536 }
537
Zhijun He2b59be82013-09-25 10:14:30 -0700538 return ret;
539}
540
Ruben Brunkcc776712015-02-17 20:18:47 -0800541String8 CameraService::getFormattedCurrentTime() {
542 time_t now = time(nullptr);
543 char formattedTime[64];
544 strftime(formattedTime, sizeof(formattedTime), "%m-%d %H:%M:%S", localtime(&now));
545 return String8(formattedTime);
546}
547
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800548Status CameraService::getCameraVendorTagDescriptor(
549 /*out*/
550 hardware::camera2::params::VendorTagDescriptor* desc) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700551 ATRACE_CALL();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800552 if (!mInitialized) {
553 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800554 return STATUS_ERROR(ERROR_DISCONNECTED, "Camera subsystem not available");
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800555 }
Eino-Ville Talvala1e74e242016-03-03 11:24:28 -0800556 sp<VendorTagDescriptor> globalDescriptor = VendorTagDescriptor::getGlobalVendorTagDescriptor();
557 if (globalDescriptor != nullptr) {
558 *desc = *(globalDescriptor.get());
559 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800560 return Status::ok();
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800561}
562
Emilian Peev71c73a22017-03-21 16:35:51 +0000563Status CameraService::getCameraVendorTagCache(
564 /*out*/ hardware::camera2::params::VendorTagDescriptorCache* cache) {
565 ATRACE_CALL();
566 if (!mInitialized) {
567 ALOGE("%s: Camera HAL couldn't be initialized", __FUNCTION__);
568 return STATUS_ERROR(ERROR_DISCONNECTED,
569 "Camera subsystem not available");
570 }
571 sp<VendorTagDescriptorCache> globalCache =
572 VendorTagDescriptorCache::getGlobalVendorTagCache();
573 if (globalCache != nullptr) {
574 *cache = *(globalCache.get());
575 }
576 return Status::ok();
577}
578
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800579int CameraService::getDeviceVersion(const String8& cameraId, int* facing) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -0700580 ATRACE_CALL();
Igor Murashkin634a5152013-02-20 17:15:11 -0800581
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800582 int deviceVersion = 0;
583
Emilian Peevf53f66e2017-04-11 14:29:43 +0100584 status_t res;
585 hardware::hidl_version maxVersion{0,0};
586 res = mCameraProviderManager->getHighestSupportedVersion(cameraId.string(),
587 &maxVersion);
588 if (res != OK) return -1;
589 deviceVersion = HARDWARE_DEVICE_API_VERSION(maxVersion.get_major(), maxVersion.get_minor());
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800590
Emilian Peevf53f66e2017-04-11 14:29:43 +0100591 hardware::CameraInfo info;
592 if (facing) {
593 res = mCameraProviderManager->getCameraInfo(cameraId.string(), &info);
Eino-Ville Talvala6963d0a2017-01-31 13:00:34 -0800594 if (res != OK) return -1;
Emilian Peevf53f66e2017-04-11 14:29:43 +0100595 *facing = info.facing;
Igor Murashkin634a5152013-02-20 17:15:11 -0800596 }
Emilian Peevf53f66e2017-04-11 14:29:43 +0100597
Igor Murashkin634a5152013-02-20 17:15:11 -0800598 return deviceVersion;
599}
600
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800601Status CameraService::filterGetInfoErrorCode(status_t err) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700602 switch(err) {
603 case NO_ERROR:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800604 return Status::ok();
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800605 case BAD_VALUE:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800606 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
607 "CameraId is not valid for HAL module");
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800608 case NO_INIT:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800609 return STATUS_ERROR(ERROR_DISCONNECTED,
610 "Camera device not available");
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700611 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800612 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
613 "Camera HAL encountered error %d: %s",
614 err, strerror(-err));
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700615 }
Igor Murashkinbfc99152013-02-27 12:55:20 -0800616}
617
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800618Status CameraService::makeClient(const sp<CameraService>& cameraService,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800619 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800620 int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700621 int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
Ruben Brunkcc776712015-02-17 20:18:47 -0800622 /*out*/sp<BasicClient>* client) {
623
Ruben Brunkcc776712015-02-17 20:18:47 -0800624 if (halVersion < 0 || halVersion == deviceVersion) {
625 // Default path: HAL version is unspecified by caller, create CameraClient
626 // based on device version reported by the HAL.
627 switch(deviceVersion) {
628 case CAMERA_DEVICE_API_VERSION_1_0:
629 if (effectiveApiLevel == API_1) { // Camera1 API route
630 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800631 *client = new CameraClient(cameraService, tmp, packageName,
632 api1CameraId, facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700633 getpid());
Ruben Brunkcc776712015-02-17 20:18:47 -0800634 } else { // Camera2 API route
635 ALOGW("Camera using old HAL version: %d", deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800636 return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800637 "Camera device \"%s\" HAL version %d does not support camera2 API",
638 cameraId.string(), deviceVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800639 }
640 break;
Ruben Brunkcc776712015-02-17 20:18:47 -0800641 case CAMERA_DEVICE_API_VERSION_3_0:
642 case CAMERA_DEVICE_API_VERSION_3_1:
643 case CAMERA_DEVICE_API_VERSION_3_2:
644 case CAMERA_DEVICE_API_VERSION_3_3:
Zhijun He4afbdec2016-05-04 15:42:51 -0700645 case CAMERA_DEVICE_API_VERSION_3_4:
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700646 case CAMERA_DEVICE_API_VERSION_3_5:
Ruben Brunkcc776712015-02-17 20:18:47 -0800647 if (effectiveApiLevel == API_1) { // Camera1 API route
648 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800649 *client = new Camera2Client(cameraService, tmp, packageName,
650 cameraId, api1CameraId,
651 facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700652 servicePid);
Ruben Brunkcc776712015-02-17 20:18:47 -0800653 } else { // Camera2 API route
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800654 sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
655 static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
656 *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
Ruben Brunkcc776712015-02-17 20:18:47 -0800657 facing, clientPid, clientUid, servicePid);
658 }
659 break;
660 default:
661 // Should not be reachable
662 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800663 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800664 "Camera device \"%s\" has unknown HAL version %d",
665 cameraId.string(), deviceVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800666 }
667 } else {
668 // A particular HAL version is requested by caller. Create CameraClient
669 // based on the requested HAL version.
670 if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
671 halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
672 // Only support higher HAL version device opened as HAL1.0 device.
673 sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800674 *client = new CameraClient(cameraService, tmp, packageName,
675 api1CameraId, facing, clientPid, clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700676 servicePid);
Ruben Brunkcc776712015-02-17 20:18:47 -0800677 } else {
678 // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
679 ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
680 " opened as HAL %x device", halVersion, deviceVersion,
681 CAMERA_DEVICE_API_VERSION_1_0);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800682 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800683 "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
684 cameraId.string(), deviceVersion, halVersion);
Ruben Brunkcc776712015-02-17 20:18:47 -0800685 }
686 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800687 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800688}
689
Ruben Brunk6267b532015-04-30 17:44:07 -0700690String8 CameraService::toString(std::set<userid_t> intSet) {
691 String8 s("");
692 bool first = true;
693 for (userid_t i : intSet) {
694 if (first) {
695 s.appendFormat("%d", i);
696 first = false;
697 } else {
698 s.appendFormat(", %d", i);
699 }
700 }
701 return s;
702}
703
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800704int32_t CameraService::mapToInterface(TorchModeStatus status) {
705 int32_t serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
706 switch (status) {
707 case TorchModeStatus::NOT_AVAILABLE:
708 serviceStatus = ICameraServiceListener::TORCH_STATUS_NOT_AVAILABLE;
709 break;
710 case TorchModeStatus::AVAILABLE_OFF:
711 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_OFF;
712 break;
713 case TorchModeStatus::AVAILABLE_ON:
714 serviceStatus = ICameraServiceListener::TORCH_STATUS_AVAILABLE_ON;
715 break;
716 default:
717 ALOGW("Unknown new flash status: %d", status);
718 }
719 return serviceStatus;
720}
721
722CameraService::StatusInternal CameraService::mapToInternal(CameraDeviceStatus status) {
723 StatusInternal serviceStatus = StatusInternal::NOT_PRESENT;
724 switch (status) {
725 case CameraDeviceStatus::NOT_PRESENT:
726 serviceStatus = StatusInternal::NOT_PRESENT;
727 break;
728 case CameraDeviceStatus::PRESENT:
729 serviceStatus = StatusInternal::PRESENT;
730 break;
731 case CameraDeviceStatus::ENUMERATING:
732 serviceStatus = StatusInternal::ENUMERATING;
733 break;
734 default:
735 ALOGW("Unknown new HAL device status: %d", status);
736 }
737 return serviceStatus;
738}
739
740int32_t CameraService::mapToInterface(StatusInternal status) {
741 int32_t serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
742 switch (status) {
743 case StatusInternal::NOT_PRESENT:
744 serviceStatus = ICameraServiceListener::STATUS_NOT_PRESENT;
745 break;
746 case StatusInternal::PRESENT:
747 serviceStatus = ICameraServiceListener::STATUS_PRESENT;
748 break;
749 case StatusInternal::ENUMERATING:
750 serviceStatus = ICameraServiceListener::STATUS_ENUMERATING;
751 break;
752 case StatusInternal::NOT_AVAILABLE:
753 serviceStatus = ICameraServiceListener::STATUS_NOT_AVAILABLE;
754 break;
755 case StatusInternal::UNKNOWN:
756 serviceStatus = ICameraServiceListener::STATUS_UNKNOWN;
757 break;
758 default:
759 ALOGW("Unknown new internal device status: %d", status);
760 }
761 return serviceStatus;
762}
763
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800764Status CameraService::initializeShimMetadata(int cameraId) {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700765 int uid = CameraThreadState::getCallingUid();
Ruben Brunkb2119af2014-05-09 19:57:56 -0700766
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800767 String16 internalPackageName("cameraserver");
Ruben Brunkcc776712015-02-17 20:18:47 -0800768 String8 id = String8::format("%d", cameraId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800769 Status ret = Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800770 sp<Client> tmp = nullptr;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800771 if (!(ret = connectHelper<ICameraClient,Client>(
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800772 sp<ICameraClient>{nullptr}, id, cameraId,
773 static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800774 internalPackageName, uid, USE_CALLING_PID,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -0700775 API_1, /*shimUpdateOnly*/ true, /*out*/ tmp)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800776 ).isOk()) {
777 ALOGE("%s: Error initializing shim metadata: %s", __FUNCTION__, ret.toString8().string());
Ruben Brunkb2119af2014-05-09 19:57:56 -0700778 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800779 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700780}
781
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800782Status CameraService::getLegacyParametersLazy(int cameraId,
Igor Murashkin65d14b92014-06-17 12:03:20 -0700783 /*out*/
784 CameraParameters* parameters) {
785
786 ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId);
787
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800788 Status ret = Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -0700789
790 if (parameters == NULL) {
791 ALOGE("%s: parameters must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800792 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
Igor Murashkin65d14b92014-06-17 12:03:20 -0700793 }
794
Ruben Brunkcc776712015-02-17 20:18:47 -0800795 String8 id = String8::format("%d", cameraId);
796
797 // Check if we already have parameters
798 {
799 // Scope for service lock
Igor Murashkin65d14b92014-06-17 12:03:20 -0700800 Mutex::Autolock lock(mServiceLock);
Ruben Brunkcc776712015-02-17 20:18:47 -0800801 auto cameraState = getCameraState(id);
802 if (cameraState == nullptr) {
803 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800804 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
805 "Invalid camera ID: %s", id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -0800806 }
807 CameraParameters p = cameraState->getShimParams();
808 if (!p.isEmpty()) {
809 *parameters = p;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800810 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700811 }
812 }
813
Jayant Chowdhary12361932018-08-27 14:46:13 -0700814 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunkcc776712015-02-17 20:18:47 -0800815 ret = initializeShimMetadata(cameraId);
Jayant Chowdhary12361932018-08-27 14:46:13 -0700816 CameraThreadState::restoreCallingIdentity(token);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800817 if (!ret.isOk()) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800818 // Error already logged by callee
819 return ret;
820 }
821
822 // Check for parameters again
823 {
824 // Scope for service lock
825 Mutex::Autolock lock(mServiceLock);
826 auto cameraState = getCameraState(id);
827 if (cameraState == nullptr) {
828 ALOGE("%s: Invalid camera ID: %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800829 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
830 "Invalid camera ID: %s", id.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -0700831 }
Ruben Brunkcc776712015-02-17 20:18:47 -0800832 CameraParameters p = cameraState->getShimParams();
833 if (!p.isEmpty()) {
834 *parameters = p;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800835 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700836 }
837 }
838
Ruben Brunkcc776712015-02-17 20:18:47 -0800839 ALOGE("%s: Parameters were not initialized, or were empty. Device may not be present.",
840 __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800841 return STATUS_ERROR(ERROR_INVALID_OPERATION, "Unable to initialize legacy parameters");
Igor Murashkin65d14b92014-06-17 12:03:20 -0700842}
843
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800844// Can camera service trust the caller based on the calling UID?
845static bool isTrustedCallingUid(uid_t uid) {
846 switch (uid) {
Eino-Ville Talvalaaf9d0302016-06-29 14:40:10 -0700847 case AID_MEDIA: // mediaserver
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800848 case AID_CAMERASERVER: // cameraserver
Eino-Ville Talvalaaf9d0302016-06-29 14:40:10 -0700849 case AID_RADIO: // telephony
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800850 return true;
851 default:
852 return false;
853 }
854}
855
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800856Status CameraService::validateConnectLocked(const String8& cameraId,
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700857 const String8& clientName8, /*inout*/int& clientUid, /*inout*/int& clientPid,
858 /*out*/int& originalClientPid) const {
Tyler Luu5861a9a2011-10-06 00:00:03 -0500859
Alex Deymo9c2a2c22016-08-25 11:59:14 -0700860#ifdef __BRILLO__
861 UNUSED(clientName8);
862 UNUSED(clientUid);
863 UNUSED(clientPid);
864 UNUSED(originalClientPid);
865#else
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700866 Status allowed = validateClientPermissionsLocked(cameraId, clientName8, clientUid, clientPid,
867 originalClientPid);
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800868 if (!allowed.isOk()) {
Christopher Wileyce761d12016-02-16 10:15:00 -0800869 return allowed;
870 }
Alex Deymo9c2a2c22016-08-25 11:59:14 -0700871#endif // __BRILLO__
Christopher Wileyce761d12016-02-16 10:15:00 -0800872
Jayant Chowdhary12361932018-08-27 14:46:13 -0700873 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800874
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800875 if (!mInitialized) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800876 ALOGE("CameraService::connect X (PID %d) rejected (camera HAL module not loaded)",
877 callingPid);
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800878 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
879 "No camera HAL module available to open camera device \"%s\"", cameraId.string());
Iliyan Malchev8951a972011-04-14 16:55:59 -0700880 }
881
Ruben Brunkcc776712015-02-17 20:18:47 -0800882 if (getCameraState(cameraId) == nullptr) {
883 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
884 cameraId.string());
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800885 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
886 "No camera device with ID \"%s\" available", cameraId.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700887 }
888
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800889 status_t err = checkIfDeviceIsUsable(cameraId);
890 if (err != NO_ERROR) {
891 switch(err) {
892 case -ENODEV:
893 case -EBUSY:
894 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
895 "No camera device with ID \"%s\" currently available", cameraId.string());
896 default:
897 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
898 "Unknown error connecting to ID \"%s\"", cameraId.string());
899 }
900 }
901 return Status::ok();
Christopher Wiley0039bcf2016-02-05 10:29:50 -0800902}
903
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800904Status CameraService::validateClientPermissionsLocked(const String8& cameraId,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700905 const String8& clientName8, int& clientUid, int& clientPid,
906 /*out*/int& originalClientPid) const {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700907 int callingPid = CameraThreadState::getCallingPid();
908 int callingUid = CameraThreadState::getCallingUid();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700909
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800910 // Check if we can trust clientUid
Mathias Agopian65ab4712010-07-14 17:59:35 -0700911 if (clientUid == USE_CALLING_UID) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800912 clientUid = callingUid;
913 } else if (!isTrustedCallingUid(callingUid)) {
914 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
915 "(don't trust clientUid %d)", callingPid, callingUid, clientUid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800916 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
917 "Untrusted caller (calling PID %d, UID %d) trying to "
918 "forward camera access to camera %s for client %s (PID %d, UID %d)",
919 callingPid, callingUid, cameraId.string(),
920 clientName8.string(), clientUid, clientPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700921 }
922
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800923 // Check if we can trust clientPid
924 if (clientPid == USE_CALLING_PID) {
925 clientPid = callingPid;
926 } else if (!isTrustedCallingUid(callingUid)) {
927 ALOGE("CameraService::connect X (calling PID %d, calling UID %d) rejected "
928 "(don't trust clientPid %d)", callingPid, callingUid, clientPid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800929 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
930 "Untrusted caller (calling PID %d, UID %d) trying to "
931 "forward camera access to camera %s for client %s (PID %d, UID %d)",
932 callingPid, callingUid, cameraId.string(),
933 clientName8.string(), clientUid, clientPid);
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800934 }
935
936 // If it's not calling from cameraserver, check the permission.
937 if (callingPid != getpid() &&
938 !checkPermission(String16("android.permission.CAMERA"), clientPid, clientUid)) {
939 ALOGE("Permission Denial: can't use the camera pid=%d, uid=%d", clientPid, clientUid);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800940 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
941 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" without camera permission",
942 clientName8.string(), clientUid, clientPid, cameraId.string());
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800943 }
944
Svet Ganova453d0d2018-01-11 15:37:58 -0800945 // Make sure the UID is in an active state to use the camera
Svet Ganov7b4ab782018-03-25 12:48:10 -0700946 if (!mUidPolicy->isUidActive(callingUid, String16(clientName8))) {
Svet Ganova453d0d2018-01-11 15:37:58 -0800947 ALOGE("Access Denial: can't use the camera from an idle UID pid=%d, uid=%d",
948 clientPid, clientUid);
949 return STATUS_ERROR_FMT(ERROR_DISABLED,
950 "Caller \"%s\" (PID %d, UID %d) cannot open camera \"%s\" from background",
951 clientName8.string(), clientUid, clientPid, cameraId.string());
952 }
953
Chien-Yu Chen4f3d6202016-03-22 10:50:23 -0700954 // Only use passed in clientPid to check permission. Use calling PID as the client PID that's
955 // connected to camera service directly.
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700956 originalClientPid = clientPid;
Chien-Yu Chen4f3d6202016-03-22 10:50:23 -0700957 clientPid = callingPid;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700958
Ruben Brunk6267b532015-04-30 17:44:07 -0700959 userid_t clientUserId = multiuser_get_user_id(clientUid);
Wu-cheng Lia3355432011-05-20 14:54:25 +0800960
Ruben Brunka8ca9152015-04-07 14:23:40 -0700961 // Only allow clients who are being used by the current foreground device user, unless calling
962 // from our own process.
Ruben Brunk6267b532015-04-30 17:44:07 -0700963 if (callingPid != getpid() && (mAllowedUsers.find(clientUserId) == mAllowedUsers.end())) {
964 ALOGE("CameraService::connect X (PID %d) rejected (cannot connect from "
965 "device user %d, currently allowed device users: %s)", callingPid, clientUserId,
966 toString(mAllowedUsers).string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800967 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
968 "Callers from device user %d are not currently allowed to connect to camera \"%s\"",
969 clientUserId, cameraId.string());
Ruben Brunk36597b22015-03-20 22:15:57 -0700970 }
971
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800972 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -0800973}
974
975status_t CameraService::checkIfDeviceIsUsable(const String8& cameraId) const {
976 auto cameraState = getCameraState(cameraId);
Jayant Chowdhary12361932018-08-27 14:46:13 -0700977 int callingPid = CameraThreadState::getCallingPid();
Ruben Brunkcc776712015-02-17 20:18:47 -0800978 if (cameraState == nullptr) {
979 ALOGE("CameraService::connect X (PID %d) rejected (invalid camera ID %s)", callingPid,
980 cameraId.string());
981 return -ENODEV;
982 }
983
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800984 StatusInternal currentStatus = cameraState->getStatus();
985 if (currentStatus == StatusInternal::NOT_PRESENT) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800986 ALOGE("CameraService::connect X (PID %d) rejected (camera %s is not connected)",
987 callingPid, cameraId.string());
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700988 return -ENODEV;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800989 } else if (currentStatus == StatusInternal::ENUMERATING) {
Ruben Brunkcc776712015-02-17 20:18:47 -0800990 ALOGE("CameraService::connect X (PID %d) rejected, (camera %s is initializing)",
991 callingPid, cameraId.string());
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700992 return -EBUSY;
Igor Murashkincba2c162013-03-20 15:56:31 -0700993 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700994
Ruben Brunkcc776712015-02-17 20:18:47 -0800995 return NO_ERROR;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800996}
997
Ruben Brunkcc776712015-02-17 20:18:47 -0800998void CameraService::finishConnectLocked(const sp<BasicClient>& client,
999 const CameraService::DescriptorPtr& desc) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001000
Ruben Brunkcc776712015-02-17 20:18:47 -08001001 // Make a descriptor for the incoming client
1002 auto clientDescriptor = CameraService::CameraClientManager::makeClientDescriptor(client, desc);
1003 auto evicted = mActiveClientManager.addAndEvict(clientDescriptor);
1004
1005 logConnected(desc->getKey(), static_cast<int>(desc->getOwnerId()),
1006 String8(client->getPackageName()));
1007
1008 if (evicted.size() > 0) {
1009 // This should never happen - clients should already have been removed in disconnect
1010 for (auto& i : evicted) {
1011 ALOGE("%s: Invalid state: Client for camera %s was not removed in disconnect",
1012 __FUNCTION__, i->getKey().string());
1013 }
1014
1015 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, clients not evicted properly",
1016 __FUNCTION__);
1017 }
Eino-Ville Talvala24901c82015-09-04 14:15:58 -07001018
1019 // And register a death notification for the client callback. Do
1020 // this last to avoid Binder policy where a nested Binder
1021 // transaction might be pre-empted to service the client death
1022 // notification if the client process dies before linkToDeath is
1023 // invoked.
1024 sp<IBinder> remoteCallback = client->getRemote();
1025 if (remoteCallback != nullptr) {
1026 remoteCallback->linkToDeath(this);
1027 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001028}
1029
1030status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clientPid,
1031 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
1032 /*out*/
1033 sp<BasicClient>* client,
1034 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001035 ATRACE_CALL();
Ruben Brunkcc776712015-02-17 20:18:47 -08001036 status_t ret = NO_ERROR;
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001037 std::vector<DescriptorPtr> evictedClients;
Ruben Brunkcc776712015-02-17 20:18:47 -08001038 DescriptorPtr clientDescriptor;
1039 {
1040 if (effectiveApiLevel == API_1) {
1041 // If we are using API1, any existing client for this camera ID with the same remote
1042 // should be returned rather than evicted to allow MediaRecorder to work properly.
1043
1044 auto current = mActiveClientManager.get(cameraId);
1045 if (current != nullptr) {
1046 auto clientSp = current->getValue();
1047 if (clientSp.get() != nullptr) { // should never be needed
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07001048 if (!clientSp->canCastToApiClient(effectiveApiLevel)) {
1049 ALOGW("CameraService connect called from same client, but with a different"
1050 " API level, evicting prior client...");
1051 } else if (clientSp->getRemote() == remoteCallback) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001052 ALOGI("CameraService::connect X (PID %d) (second call from same"
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07001053 " app binder, returning the same client)", clientPid);
Ruben Brunkcc776712015-02-17 20:18:47 -08001054 *client = clientSp;
1055 return NO_ERROR;
1056 }
1057 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001058 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001059 }
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +08001060
Ruben Brunkcc776712015-02-17 20:18:47 -08001061 // Get current active client PIDs
1062 std::vector<int> ownerPids(mActiveClientManager.getAllOwners());
1063 ownerPids.push_back(clientPid);
Igor Murashkine6800ce2013-03-04 17:25:57 -08001064
Emilian Peev8131a262017-02-01 12:33:43 +00001065 std::vector<int> priorityScores(ownerPids.size());
1066 std::vector<int> states(ownerPids.size());
Igor Murashkine6800ce2013-03-04 17:25:57 -08001067
Emilian Peev8131a262017-02-01 12:33:43 +00001068 // Get priority scores of all active PIDs
1069 status_t err = ProcessInfoService::getProcessStatesScoresFromPids(
1070 ownerPids.size(), &ownerPids[0], /*out*/&states[0],
1071 /*out*/&priorityScores[0]);
1072 if (err != OK) {
1073 ALOGE("%s: Priority score query failed: %d",
1074 __FUNCTION__, err);
1075 return err;
1076 }
Ruben Brunkb2119af2014-05-09 19:57:56 -07001077
Ruben Brunkcc776712015-02-17 20:18:47 -08001078 // Update all active clients' priorities
Emilian Peev8131a262017-02-01 12:33:43 +00001079 std::map<int,resource_policy::ClientPriority> pidToPriorityMap;
Ruben Brunkcc776712015-02-17 20:18:47 -08001080 for (size_t i = 0; i < ownerPids.size() - 1; i++) {
Emilian Peev8131a262017-02-01 12:33:43 +00001081 pidToPriorityMap.emplace(ownerPids[i],
1082 resource_policy::ClientPriority(priorityScores[i], states[i]));
Ruben Brunkcc776712015-02-17 20:18:47 -08001083 }
1084 mActiveClientManager.updatePriorities(pidToPriorityMap);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001085
Ruben Brunkcc776712015-02-17 20:18:47 -08001086 // Get state for the given cameraId
1087 auto state = getCameraState(cameraId);
1088 if (state == nullptr) {
1089 ALOGE("CameraService::connect X (PID %d) rejected (no camera device with ID %s)",
1090 clientPid, cameraId.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001091 // Should never get here because validateConnectLocked should have errored out
Zhijun Heb10cdad2014-06-16 16:38:35 -07001092 return BAD_VALUE;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001093 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001094
1095 // Make descriptor for incoming client
Shuzhen Wang2db86ff2018-04-25 01:11:17 +00001096 clientDescriptor = CameraClientManager::makeClientDescriptor(cameraId,
Ruben Brunkcc776712015-02-17 20:18:47 -08001097 sp<BasicClient>{nullptr}, static_cast<int32_t>(state->getCost()),
1098 state->getConflicting(),
Emilian Peev8131a262017-02-01 12:33:43 +00001099 priorityScores[priorityScores.size() - 1],
1100 clientPid,
1101 states[states.size() - 1]);
Ruben Brunkcc776712015-02-17 20:18:47 -08001102
1103 // Find clients that would be evicted
1104 auto evicted = mActiveClientManager.wouldEvict(clientDescriptor);
1105
1106 // If the incoming client was 'evicted,' higher priority clients have the camera in the
1107 // background, so we cannot do evictions
1108 if (std::find(evicted.begin(), evicted.end(), clientDescriptor) != evicted.end()) {
1109 ALOGE("CameraService::connect X (PID %d) rejected (existing client(s) with higher"
1110 " priority).", clientPid);
1111
1112 sp<BasicClient> clientSp = clientDescriptor->getValue();
1113 String8 curTime = getFormattedCurrentTime();
1114 auto incompatibleClients =
1115 mActiveClientManager.getIncompatibleClients(clientDescriptor);
1116
1117 String8 msg = String8::format("%s : DENIED connect device %s client for package %s "
Emilian Peev8131a262017-02-01 12:33:43 +00001118 "(PID %d, score %d state %d) due to eviction policy", curTime.string(),
Ruben Brunkcc776712015-02-17 20:18:47 -08001119 cameraId.string(), packageName.string(), clientPid,
Emilian Peev8131a262017-02-01 12:33:43 +00001120 priorityScores[priorityScores.size() - 1],
1121 states[states.size() - 1]);
Ruben Brunkcc776712015-02-17 20:18:47 -08001122
1123 for (auto& i : incompatibleClients) {
1124 msg.appendFormat("\n - Blocked by existing device %s client for package %s"
Emilian Peev8131a262017-02-01 12:33:43 +00001125 "(PID %" PRId32 ", score %" PRId32 ", state %" PRId32 ")",
1126 i->getKey().string(),
1127 String8{i->getValue()->getPackageName()}.string(),
1128 i->getOwnerId(), i->getPriority().getScore(),
1129 i->getPriority().getState());
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07001130 ALOGE(" Conflicts with: Device %s, client package %s (PID %"
Emilian Peev8131a262017-02-01 12:33:43 +00001131 PRId32 ", score %" PRId32 ", state %" PRId32 ")", i->getKey().string(),
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07001132 String8{i->getValue()->getPackageName()}.string(), i->getOwnerId(),
Emilian Peev8131a262017-02-01 12:33:43 +00001133 i->getPriority().getScore(), i->getPriority().getState());
Ruben Brunkcc776712015-02-17 20:18:47 -08001134 }
1135
1136 // Log the client's attempt
Ruben Brunka8ca9152015-04-07 14:23:40 -07001137 Mutex::Autolock l(mLogLock);
Ruben Brunkcc776712015-02-17 20:18:47 -08001138 mEventLog.add(msg);
1139
1140 return -EBUSY;
1141 }
1142
1143 for (auto& i : evicted) {
1144 sp<BasicClient> clientSp = i->getValue();
1145 if (clientSp.get() == nullptr) {
1146 ALOGE("%s: Invalid state: Null client in active client list.", __FUNCTION__);
1147
1148 // TODO: Remove this
1149 LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, null client in active list",
1150 __FUNCTION__);
1151 mActiveClientManager.remove(i);
1152 continue;
1153 }
1154
1155 ALOGE("CameraService::connect evicting conflicting client for camera ID %s",
1156 i->getKey().string());
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001157 evictedClients.push_back(i);
Ruben Brunkcc776712015-02-17 20:18:47 -08001158
Ruben Brunkcc776712015-02-17 20:18:47 -08001159 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07001160 logEvent(String8::format("EVICT device %s client held by package %s (PID"
Emilian Peev8131a262017-02-01 12:33:43 +00001161 " %" PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted by device %s client for"
1162 " package %s (PID %d, score %" PRId32 ", state %" PRId32 ")",
Ruben Brunkcc776712015-02-17 20:18:47 -08001163 i->getKey().string(), String8{clientSp->getPackageName()}.string(),
Emilian Peev8131a262017-02-01 12:33:43 +00001164 i->getOwnerId(), i->getPriority().getScore(),
1165 i->getPriority().getState(), cameraId.string(),
Ruben Brunkcc776712015-02-17 20:18:47 -08001166 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 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001171 clientSp->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -08001172 CaptureResultExtras());
Zhijun Heb10cdad2014-06-16 16:38:35 -07001173 }
Ruben Brunkb2119af2014-05-09 19:57:56 -07001174 }
1175
Ruben Brunkcc776712015-02-17 20:18:47 -08001176 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1177 // other clients from connecting in mServiceLockWrapper if held
1178 mServiceLock.unlock();
1179
1180 // Clear caller identity temporarily so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -07001181 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunkcc776712015-02-17 20:18:47 -08001182
1183 // Destroy evicted clients
1184 for (auto& i : evictedClients) {
1185 // Disconnect is blocking, and should only have returned when HAL has cleaned up
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001186 i->getValue()->disconnect(); // Clients will remove themselves from the active client list
Ruben Brunkcc776712015-02-17 20:18:47 -08001187 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001188
Jayant Chowdhary12361932018-08-27 14:46:13 -07001189 CameraThreadState::restoreCallingIdentity(token);
Ruben Brunkcc776712015-02-17 20:18:47 -08001190
Ruben Brunk4f9576b2015-04-10 17:26:56 -07001191 for (const auto& i : evictedClients) {
1192 ALOGV("%s: Waiting for disconnect to complete for client for device %s (PID %" PRId32 ")",
1193 __FUNCTION__, i->getKey().string(), i->getOwnerId());
1194 ret = mActiveClientManager.waitUntilRemoved(i, DEFAULT_DISCONNECT_TIMEOUT_NS);
1195 if (ret == TIMED_OUT) {
1196 ALOGE("%s: Timed out waiting for client for device %s to disconnect, "
1197 "current clients:\n%s", __FUNCTION__, i->getKey().string(),
1198 mActiveClientManager.toString().string());
1199 return -EBUSY;
1200 }
1201 if (ret != NO_ERROR) {
1202 ALOGE("%s: Received error waiting for client for device %s to disconnect: %s (%d), "
1203 "current clients:\n%s", __FUNCTION__, i->getKey().string(), strerror(-ret),
1204 ret, mActiveClientManager.toString().string());
1205 return ret;
1206 }
1207 }
1208
1209 evictedClients.clear();
1210
Ruben Brunkcc776712015-02-17 20:18:47 -08001211 // Once clients have been disconnected, relock
1212 mServiceLock.lock();
1213
1214 // Check again if the device was unplugged or something while we weren't holding mServiceLock
1215 if ((ret = checkIfDeviceIsUsable(cameraId)) != NO_ERROR) {
1216 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -07001217 }
1218
Ruben Brunkcc776712015-02-17 20:18:47 -08001219 *partial = clientDescriptor;
1220 return NO_ERROR;
Ruben Brunkb2119af2014-05-09 19:57:56 -07001221}
1222
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001223Status CameraService::connect(
Igor Murashkine6800ce2013-03-04 17:25:57 -08001224 const sp<ICameraClient>& cameraClient,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001225 int api1CameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001226 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001227 int clientUid,
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001228 int clientPid,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001229 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001230 sp<ICamera>* device) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001231
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001232 ATRACE_CALL();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001233 Status ret = Status::ok();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001234
1235 String8 id = cameraIdIntToStr(api1CameraId);
Ruben Brunkcc776712015-02-17 20:18:47 -08001236 sp<Client> client = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001237 ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001238 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001239 /*shimUpdateOnly*/ false, /*out*/client);
Igor Murashkine6800ce2013-03-04 17:25:57 -08001240
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001241 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001242 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001243 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001244 return ret;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001245 }
1246
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001247 *device = client;
1248 return ret;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001249}
1250
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001251Status CameraService::connectLegacy(
Zhijun Heb10cdad2014-06-16 16:38:35 -07001252 const sp<ICameraClient>& cameraClient,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001253 int api1CameraId, int halVersion,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001254 const String16& clientPackageName,
Zhijun Heb10cdad2014-06-16 16:38:35 -07001255 int clientUid,
1256 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001257 sp<ICamera>* device) {
Zhijun Heb10cdad2014-06-16 16:38:35 -07001258
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001259 ATRACE_CALL();
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001260 String8 id = cameraIdIntToStr(api1CameraId);
Zhijun Heb10cdad2014-06-16 16:38:35 -07001261
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001262 Status ret = Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001263 sp<Client> client = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001264 ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId, halVersion,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001265 clientPackageName, clientUid, USE_CALLING_PID, API_1, /*shimUpdateOnly*/ false,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001266 /*out*/client);
Zhijun Heb10cdad2014-06-16 16:38:35 -07001267
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001268 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001269 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001270 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001271 return ret;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001272 }
1273
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001274 *device = client;
1275 return ret;
Zhijun Heb10cdad2014-06-16 16:38:35 -07001276}
1277
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001278Status CameraService::connectDevice(
1279 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001280 const String16& cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001281 const String16& clientPackageName,
Ruben Brunkcc776712015-02-17 20:18:47 -08001282 int clientUid,
1283 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001284 sp<hardware::camera2::ICameraDeviceUser>* device) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001285
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001286 ATRACE_CALL();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001287 Status ret = Status::ok();
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001288 String8 id = String8(cameraId);
Ruben Brunkcc776712015-02-17 20:18:47 -08001289 sp<CameraDeviceClient> client = nullptr;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001290 ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001291 /*api1CameraId*/-1,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001292 CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001293 clientUid, USE_CALLING_PID, API_2, /*shimUpdateOnly*/ false, /*out*/client);
Ruben Brunkcc776712015-02-17 20:18:47 -08001294
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001295 if(!ret.isOk()) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07001296 logRejected(id, CameraThreadState::getCallingPid(), String8(clientPackageName),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001297 ret.toString8());
Ruben Brunkcc776712015-02-17 20:18:47 -08001298 return ret;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001299 }
1300
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001301 *device = client;
1302 return ret;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001303}
1304
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001305template<class CALLBACK, class CLIENT>
1306Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001307 int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001308 int clientPid, apiLevel effectiveApiLevel, bool shimUpdateOnly,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001309 /*out*/sp<CLIENT>& device) {
1310 binder::Status ret = binder::Status::ok();
1311
1312 String8 clientName8(clientPackageName);
1313
1314 int originalClientPid = 0;
1315
1316 ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
1317 "Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
1318 (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
1319 static_cast<int>(effectiveApiLevel));
1320
1321 sp<CLIENT> client = nullptr;
1322 {
1323 // Acquire mServiceLock and prevent other clients from connecting
1324 std::unique_ptr<AutoConditionLock> lock =
1325 AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
1326
1327 if (lock == nullptr) {
1328 ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
1329 , clientPid);
1330 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1331 "Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
1332 cameraId.string(), clientName8.string(), clientPid);
1333 }
1334
1335 // Enforce client permissions and do basic sanity checks
1336 if(!(ret = validateConnectLocked(cameraId, clientName8,
1337 /*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
1338 return ret;
1339 }
1340
1341 // Check the shim parameters after acquiring lock, if they have already been updated and
1342 // we were doing a shim update, return immediately
1343 if (shimUpdateOnly) {
1344 auto cameraState = getCameraState(cameraId);
1345 if (cameraState != nullptr) {
1346 if (!cameraState->getShimParams().isEmpty()) return ret;
1347 }
1348 }
1349
1350 status_t err;
1351
1352 sp<BasicClient> clientTmp = nullptr;
1353 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
1354 if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
1355 IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
1356 /*out*/&partial)) != NO_ERROR) {
1357 switch (err) {
1358 case -ENODEV:
1359 return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
1360 "No camera device with ID \"%s\" currently available",
1361 cameraId.string());
1362 case -EBUSY:
1363 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1364 "Higher-priority client using camera, ID \"%s\" currently unavailable",
1365 cameraId.string());
1366 default:
1367 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1368 "Unexpected error %s (%d) opening camera \"%s\"",
1369 strerror(-err), err, cameraId.string());
1370 }
1371 }
1372
1373 if (clientTmp.get() != nullptr) {
1374 // Handle special case for API1 MediaRecorder where the existing client is returned
1375 device = static_cast<CLIENT*>(clientTmp.get());
1376 return ret;
1377 }
1378
1379 // give flashlight a chance to close devices if necessary.
1380 mFlashlight->prepareDeviceOpen(cameraId);
1381
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001382 int facing = -1;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001383 int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
Eino-Ville Talvala6963d0a2017-01-31 13:00:34 -08001384 if (facing == -1) {
1385 ALOGE("%s: Unable to get camera device \"%s\" facing", __FUNCTION__, cameraId.string());
1386 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1387 "Unable to get camera device \"%s\" facing", cameraId.string());
1388 }
1389
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001390 sp<BasicClient> tmp = nullptr;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001391 if(!(ret = makeClient(this, cameraCb, clientPackageName,
1392 cameraId, api1CameraId, facing,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001393 clientPid, clientUid, getpid(),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001394 halVersion, deviceVersion, effectiveApiLevel,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001395 /*out*/&tmp)).isOk()) {
1396 return ret;
1397 }
1398 client = static_cast<CLIENT*>(tmp.get());
1399
1400 LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
1401 __FUNCTION__);
1402
Emilian Peevbd8c5032018-02-14 23:05:40 +00001403 err = client->initialize(mCameraProviderManager, mMonitorTags);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001404 if (err != OK) {
1405 ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001406 // Errors could be from the HAL module open call or from AppOpsManager
1407 switch(err) {
1408 case BAD_VALUE:
1409 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1410 "Illegal argument to HAL module for camera \"%s\"", cameraId.string());
1411 case -EBUSY:
1412 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1413 "Camera \"%s\" is already open", cameraId.string());
1414 case -EUSERS:
1415 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1416 "Too many cameras already open, cannot open camera \"%s\"",
1417 cameraId.string());
1418 case PERMISSION_DENIED:
1419 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
1420 "No permission to open camera \"%s\"", cameraId.string());
1421 case -EACCES:
1422 return STATUS_ERROR_FMT(ERROR_DISABLED,
1423 "Camera \"%s\" disabled by policy", cameraId.string());
1424 case -ENODEV:
1425 default:
1426 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1427 "Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
1428 strerror(-err), err);
1429 }
1430 }
1431
1432 // Update shim paremeters for legacy clients
1433 if (effectiveApiLevel == API_1) {
1434 // Assume we have always received a Client subclass for API1
1435 sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
1436 String8 rawParams = shimClient->getParameters();
1437 CameraParameters params(rawParams);
1438
1439 auto cameraState = getCameraState(cameraId);
1440 if (cameraState != nullptr) {
1441 cameraState->setShimParams(params);
1442 } else {
1443 ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
1444 __FUNCTION__, cameraId.string());
1445 }
1446 }
1447
1448 if (shimUpdateOnly) {
1449 // If only updating legacy shim parameters, immediately disconnect client
1450 mServiceLock.unlock();
1451 client->disconnect();
1452 mServiceLock.lock();
1453 } else {
1454 // Otherwise, add client to active clients list
1455 finishConnectLocked(client, partial);
1456 }
1457 } // lock is destroyed, allow further connect calls
1458
1459 // Important: release the mutex here so the client can call back into the service from its
1460 // destructor (can be at the end of the call)
1461 device = client;
1462 return ret;
1463}
1464
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001465Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001466 const sp<IBinder>& clientBinder) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001467 Mutex::Autolock lock(mServiceLock);
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001468
1469 ATRACE_CALL();
Ruben Brunk99e69712015-05-26 17:25:07 -07001470 if (enabled && clientBinder == nullptr) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001471 ALOGE("%s: torch client binder is NULL", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001472 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT,
1473 "Torch client Binder is null");
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001474 }
1475
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001476 String8 id = String8(cameraId.string());
Jayant Chowdhary12361932018-08-27 14:46:13 -07001477 int uid = CameraThreadState::getCallingUid();
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001478
1479 // verify id is valid.
Ruben Brunkcc776712015-02-17 20:18:47 -08001480 auto state = getCameraState(id);
1481 if (state == nullptr) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07001482 ALOGE("%s: camera id is invalid %s", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001483 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1484 "Camera ID \"%s\" is a not valid camera ID", id.string());
Ruben Brunkcc776712015-02-17 20:18:47 -08001485 }
1486
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001487 StatusInternal cameraStatus = state->getStatus();
1488 if (cameraStatus != StatusInternal::PRESENT &&
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001489 cameraStatus != StatusInternal::NOT_AVAILABLE) {
1490 ALOGE("%s: camera id is invalid %s, status %d", __FUNCTION__, id.string(), (int)cameraStatus);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001491 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1492 "Camera ID \"%s\" is a not valid camera ID", id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001493 }
1494
1495 {
1496 Mutex::Autolock al(mTorchStatusMutex);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001497 TorchModeStatus status;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001498 status_t err = getTorchStatusLocked(id, &status);
1499 if (err != OK) {
1500 if (err == NAME_NOT_FOUND) {
1501 return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
1502 "Camera \"%s\" does not have a flash unit", id.string());
1503 }
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001504 ALOGE("%s: getting current torch status failed for camera %s",
1505 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001506 return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
1507 "Error updating torch status for camera \"%s\": %s (%d)", id.string(),
1508 strerror(-err), err);
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001509 }
1510
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001511 if (status == TorchModeStatus::NOT_AVAILABLE) {
Yin-Chia Yeh52778d42016-12-22 18:20:43 -08001512 if (cameraStatus == StatusInternal::NOT_AVAILABLE) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001513 ALOGE("%s: torch mode of camera %s is not available because "
1514 "camera is in use", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001515 return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
1516 "Torch for camera \"%s\" is not available due to an existing camera user",
1517 id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001518 } else {
1519 ALOGE("%s: torch mode of camera %s is not available due to "
1520 "insufficient resources", __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001521 return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
1522 "Torch for camera \"%s\" is not available due to insufficient resources",
1523 id.string());
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001524 }
1525 }
1526 }
1527
Ruben Brunk99e69712015-05-26 17:25:07 -07001528 {
1529 // Update UID map - this is used in the torch status changed callbacks, so must be done
1530 // before setTorchMode
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001531 Mutex::Autolock al(mTorchUidMapMutex);
Ruben Brunk99e69712015-05-26 17:25:07 -07001532 if (mTorchUidMap.find(id) == mTorchUidMap.end()) {
1533 mTorchUidMap[id].first = uid;
1534 mTorchUidMap[id].second = uid;
1535 } else {
1536 // Set the pending UID
1537 mTorchUidMap[id].first = uid;
1538 }
1539 }
1540
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001541 status_t err = mFlashlight->setTorchMode(id, enabled);
Ruben Brunk99e69712015-05-26 17:25:07 -07001542
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001543 if (err != OK) {
1544 int32_t errorCode;
1545 String8 msg;
1546 switch (err) {
1547 case -ENOSYS:
1548 msg = String8::format("Camera \"%s\" has no flashlight",
1549 id.string());
1550 errorCode = ERROR_ILLEGAL_ARGUMENT;
1551 break;
1552 default:
1553 msg = String8::format(
1554 "Setting torch mode of camera \"%s\" to %d failed: %s (%d)",
1555 id.string(), enabled, strerror(-err), err);
1556 errorCode = ERROR_INVALID_OPERATION;
1557 }
1558 ALOGE("%s: %s", __FUNCTION__, msg.string());
1559 return STATUS_ERROR(errorCode, msg.string());
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001560 }
1561
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001562 {
1563 // update the link to client's death
1564 Mutex::Autolock al(mTorchClientMapMutex);
1565 ssize_t index = mTorchClientMap.indexOfKey(id);
1566 if (enabled) {
1567 if (index == NAME_NOT_FOUND) {
1568 mTorchClientMap.add(id, clientBinder);
1569 } else {
Ruben Brunk99e69712015-05-26 17:25:07 -07001570 mTorchClientMap.valueAt(index)->unlinkToDeath(this);
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001571 mTorchClientMap.replaceValueAt(index, clientBinder);
1572 }
1573 clientBinder->linkToDeath(this);
1574 } else if (index != NAME_NOT_FOUND) {
Ruben Brunk99e69712015-05-26 17:25:07 -07001575 mTorchClientMap.valueAt(index)->unlinkToDeath(this);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001576 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001577 }
1578
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001579 return Status::ok();
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001580}
1581
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001582Status CameraService::notifySystemEvent(int32_t eventId,
1583 const std::vector<int32_t>& args) {
Jeongik Chaaa5e64c2018-11-17 05:08:04 +09001584 const int pid = CameraThreadState::getCallingPid();
1585 const int selfPid = getpid();
1586
1587 // Permission checks
1588 if (pid != selfPid) {
1589 // Ensure we're being called by system_server, or similar process with
1590 // permissions to notify the camera service about system events
1591 if (!checkCallingPermission(
1592 String16("android.permission.CAMERA_SEND_SYSTEM_EVENTS"))) {
1593 const int uid = CameraThreadState::getCallingUid();
1594 ALOGE("Permission Denial: cannot send updates to camera service about system"
1595 " events from pid=%d, uid=%d", pid, uid);
1596 return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
Jeongik Chaaa1b8152018-11-21 10:02:25 +09001597 "No permission to send updates to camera service about system events"
1598 " from pid=%d, uid=%d", pid, uid);
Jeongik Chaaa5e64c2018-11-17 05:08:04 +09001599 }
1600 }
1601
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001602 ATRACE_CALL();
1603
Ruben Brunk36597b22015-03-20 22:15:57 -07001604 switch(eventId) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001605 case ICameraService::EVENT_USER_SWITCHED: {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07001606 // Try to register for UID policy updates, in case we're recovering
1607 // from a system server crash
1608 mUidPolicy->registerSelf();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001609 doUserSwitch(/*newUserIds*/ args);
Ruben Brunk36597b22015-03-20 22:15:57 -07001610 break;
1611 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001612 case ICameraService::EVENT_NONE:
Ruben Brunk36597b22015-03-20 22:15:57 -07001613 default: {
1614 ALOGW("%s: Received invalid system event from system_server: %d", __FUNCTION__,
1615 eventId);
1616 break;
1617 }
1618 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001619 return Status::ok();
Ruben Brunk36597b22015-03-20 22:15:57 -07001620}
1621
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001622Status CameraService::addListener(const sp<ICameraServiceListener>& listener,
1623 /*out*/
1624 std::vector<hardware::CameraStatus> *cameraStatuses) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001625 ATRACE_CALL();
1626
Igor Murashkinbfc99152013-02-27 12:55:20 -08001627 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
Igor Murashkin634a5152013-02-20 17:15:11 -08001628
Ruben Brunk3450ba72015-06-16 11:00:37 -07001629 if (listener == nullptr) {
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001630 ALOGE("%s: Listener must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001631 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to addListener");
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001632 }
1633
Igor Murashkinbfc99152013-02-27 12:55:20 -08001634 Mutex::Autolock lock(mServiceLock);
1635
Ruben Brunkcc776712015-02-17 20:18:47 -08001636 {
1637 Mutex::Autolock lock(mStatusListenerLock);
1638 for (auto& it : mListenerList) {
1639 if (IInterface::asBinder(it) == IInterface::asBinder(listener)) {
1640 ALOGW("%s: Tried to add listener %p which was already subscribed",
1641 __FUNCTION__, listener.get());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001642 return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
Ruben Brunkcc776712015-02-17 20:18:47 -08001643 }
Igor Murashkinbfc99152013-02-27 12:55:20 -08001644 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001645
1646 mListenerList.push_back(listener);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001647 }
1648
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001649 /* Collect current devices and status */
Igor Murashkincba2c162013-03-20 15:56:31 -07001650 {
Ruben Brunkcc776712015-02-17 20:18:47 -08001651 Mutex::Autolock lock(mCameraStatesLock);
1652 for (auto& i : mCameraStates) {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001653 cameraStatuses->emplace_back(i.first, mapToInterface(i.second->getStatus()));
Igor Murashkincba2c162013-03-20 15:56:31 -07001654 }
1655 }
1656
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001657 /*
1658 * Immediately signal current torch status to this listener only
1659 * This may be a subset of all the devices, so don't include it in the response directly
1660 */
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001661 {
1662 Mutex::Autolock al(mTorchStatusMutex);
1663 for (size_t i = 0; i < mTorchStatusMap.size(); i++ ) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001664 String16 id = String16(mTorchStatusMap.keyAt(i).string());
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001665 listener->onTorchStatusChanged(mapToInterface(mTorchStatusMap.valueAt(i)), id);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001666 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001667 }
1668
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001669 return Status::ok();
Igor Murashkinbfc99152013-02-27 12:55:20 -08001670}
Ruben Brunkcc776712015-02-17 20:18:47 -08001671
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001672Status CameraService::removeListener(const sp<ICameraServiceListener>& listener) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001673 ATRACE_CALL();
1674
Igor Murashkinbfc99152013-02-27 12:55:20 -08001675 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
1676
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001677 if (listener == 0) {
1678 ALOGE("%s: Listener must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001679 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Null listener given to removeListener");
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001680 }
1681
Igor Murashkinbfc99152013-02-27 12:55:20 -08001682 Mutex::Autolock lock(mServiceLock);
1683
Ruben Brunkcc776712015-02-17 20:18:47 -08001684 {
1685 Mutex::Autolock lock(mStatusListenerLock);
1686 for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) {
1687 if (IInterface::asBinder(*it) == IInterface::asBinder(listener)) {
1688 mListenerList.erase(it);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001689 return Status::ok();
Ruben Brunkcc776712015-02-17 20:18:47 -08001690 }
Igor Murashkinbfc99152013-02-27 12:55:20 -08001691 }
1692 }
1693
1694 ALOGW("%s: Tried to remove a listener %p which was not subscribed",
1695 __FUNCTION__, listener.get());
1696
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001697 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Unregistered listener given to removeListener");
Igor Murashkin634a5152013-02-20 17:15:11 -08001698}
1699
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001700Status CameraService::getLegacyParameters(int cameraId, /*out*/String16* parameters) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001701
1702 ATRACE_CALL();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001703 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1704
1705 if (parameters == NULL) {
1706 ALOGE("%s: parameters must not be null", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001707 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Parameters must not be null");
Igor Murashkin65d14b92014-06-17 12:03:20 -07001708 }
1709
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001710 Status ret = Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001711
1712 CameraParameters shimParams;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001713 if (!(ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)).isOk()) {
Igor Murashkin65d14b92014-06-17 12:03:20 -07001714 // Error logged by caller
1715 return ret;
1716 }
1717
1718 String8 shimParamsString8 = shimParams.flatten();
1719 String16 shimParamsString16 = String16(shimParamsString8);
1720
1721 *parameters = shimParamsString16;
1722
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001723 return ret;
Igor Murashkin65d14b92014-06-17 12:03:20 -07001724}
1725
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001726Status CameraService::supportsCameraApi(const String16& cameraId, int apiVersion,
1727 /*out*/ bool *isSupported) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07001728 ATRACE_CALL();
1729
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001730 const String8 id = String8(cameraId);
1731
1732 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001733
1734 switch (apiVersion) {
1735 case API_VERSION_1:
1736 case API_VERSION_2:
1737 break;
1738 default:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001739 String8 msg = String8::format("Unknown API version %d", apiVersion);
1740 ALOGE("%s: %s", __FUNCTION__, msg.string());
1741 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001742 }
1743
Emilian Peev28ad2ea2017-02-07 16:14:32 +00001744 int deviceVersion = getDeviceVersion(id);
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001745 switch (deviceVersion) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001746 case CAMERA_DEVICE_API_VERSION_1_0:
1747 case CAMERA_DEVICE_API_VERSION_3_0:
1748 case CAMERA_DEVICE_API_VERSION_3_1:
1749 if (apiVersion == API_VERSION_2) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001750 ALOGV("%s: Camera id %s uses HAL version %d <3.2, doesn't support api2 without shim",
1751 __FUNCTION__, id.string(), deviceVersion);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001752 *isSupported = false;
1753 } else { // if (apiVersion == API_VERSION_1) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001754 ALOGV("%s: Camera id %s uses older HAL before 3.2, but api1 is always supported",
1755 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001756 *isSupported = true;
1757 }
1758 break;
1759 case CAMERA_DEVICE_API_VERSION_3_2:
1760 case CAMERA_DEVICE_API_VERSION_3_3:
Zhijun He4afbdec2016-05-04 15:42:51 -07001761 case CAMERA_DEVICE_API_VERSION_3_4:
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001762 case CAMERA_DEVICE_API_VERSION_3_5:
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001763 ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
1764 __FUNCTION__, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001765 *isSupported = true;
1766 break;
1767 case -1: {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001768 String8 msg = String8::format("Unknown camera ID %s", id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001769 ALOGE("%s: %s", __FUNCTION__, msg.string());
1770 return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkin65d14b92014-06-17 12:03:20 -07001771 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001772 default: {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001773 String8 msg = String8::format("Unknown device version %x for device %s",
1774 deviceVersion, id.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001775 ALOGE("%s: %s", __FUNCTION__, msg.string());
1776 return STATUS_ERROR(ERROR_INVALID_OPERATION, msg.string());
1777 }
Igor Murashkin65d14b92014-06-17 12:03:20 -07001778 }
1779
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001780 return Status::ok();
Igor Murashkin65d14b92014-06-17 12:03:20 -07001781}
1782
Shuzhen Wangf9d2c022018-08-21 12:07:35 -07001783Status CameraService::isHiddenPhysicalCamera(const String16& cameraId,
1784 /*out*/ bool *isSupported) {
1785 ATRACE_CALL();
1786
1787 const String8 id = String8(cameraId);
1788
1789 ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
1790 *isSupported = mCameraProviderManager->isHiddenPhysicalCamera(id.string());
1791
1792 return Status::ok();
1793}
1794
Ruben Brunkcc776712015-02-17 20:18:47 -08001795void CameraService::removeByClient(const BasicClient* client) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001796 Mutex::Autolock lock(mServiceLock);
Ruben Brunkcc776712015-02-17 20:18:47 -08001797 for (auto& i : mActiveClientManager.getAll()) {
1798 auto clientSp = i->getValue();
1799 if (clientSp.get() == client) {
1800 mActiveClientManager.remove(i);
Igor Murashkin634a5152013-02-20 17:15:11 -08001801 }
Igor Murashkinecf17e82012-10-02 16:05:11 -07001802 }
Igor Murashkin634a5152013-02-20 17:15:11 -08001803}
1804
Ruben Brunkcc776712015-02-17 20:18:47 -08001805bool CameraService::evictClientIdByRemote(const wp<IBinder>& remote) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001806 bool ret = false;
1807 {
1808 // Acquire mServiceLock and prevent other clients from connecting
1809 std::unique_ptr<AutoConditionLock> lock =
1810 AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
Igor Murashkin634a5152013-02-20 17:15:11 -08001811
Igor Murashkin634a5152013-02-20 17:15:11 -08001812
Ruben Brunkcc776712015-02-17 20:18:47 -08001813 std::vector<sp<BasicClient>> evicted;
1814 for (auto& i : mActiveClientManager.getAll()) {
1815 auto clientSp = i->getValue();
1816 if (clientSp.get() == nullptr) {
1817 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
1818 mActiveClientManager.remove(i);
1819 continue;
1820 }
Yin-Chia Yehdbfcb382018-02-16 11:17:36 -08001821 if (remote == clientSp->getRemote()) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001822 mActiveClientManager.remove(i);
1823 evicted.push_back(clientSp);
Igor Murashkin634a5152013-02-20 17:15:11 -08001824
Ruben Brunkcc776712015-02-17 20:18:47 -08001825 // Notify the client of disconnection
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001826 clientSp->notifyError(
1827 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
Ruben Brunkcc776712015-02-17 20:18:47 -08001828 CaptureResultExtras());
Igor Murashkin634a5152013-02-20 17:15:11 -08001829 }
1830 }
1831
Ruben Brunkcc776712015-02-17 20:18:47 -08001832 // Do not hold mServiceLock while disconnecting clients, but retain the condition blocking
1833 // other clients from connecting in mServiceLockWrapper if held
1834 mServiceLock.unlock();
1835
Ruben Brunk36597b22015-03-20 22:15:57 -07001836 // Do not clear caller identity, remote caller should be client proccess
1837
Ruben Brunkcc776712015-02-17 20:18:47 -08001838 for (auto& i : evicted) {
1839 if (i.get() != nullptr) {
1840 i->disconnect();
1841 ret = true;
1842 }
Igor Murashkin634a5152013-02-20 17:15:11 -08001843 }
1844
Ruben Brunkcc776712015-02-17 20:18:47 -08001845 // Reacquire mServiceLock
1846 mServiceLock.lock();
Igor Murashkin634a5152013-02-20 17:15:11 -08001847
Ruben Brunkcc776712015-02-17 20:18:47 -08001848 } // lock is destroyed, allow further connect calls
1849
1850 return ret;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001851}
1852
Ruben Brunkcc776712015-02-17 20:18:47 -08001853std::shared_ptr<CameraService::CameraState> CameraService::getCameraState(
1854 const String8& cameraId) const {
1855 std::shared_ptr<CameraState> state;
1856 {
1857 Mutex::Autolock lock(mCameraStatesLock);
1858 auto iter = mCameraStates.find(cameraId);
1859 if (iter != mCameraStates.end()) {
1860 state = iter->second;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001861 }
1862 }
Ruben Brunkcc776712015-02-17 20:18:47 -08001863 return state;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001864}
1865
Ruben Brunkcc776712015-02-17 20:18:47 -08001866sp<CameraService::BasicClient> CameraService::removeClientLocked(const String8& cameraId) {
1867 // Remove from active clients list
1868 auto clientDescriptorPtr = mActiveClientManager.remove(cameraId);
1869 if (clientDescriptorPtr == nullptr) {
1870 ALOGW("%s: Could not evict client, no client for camera ID %s", __FUNCTION__,
1871 cameraId.string());
1872 return sp<BasicClient>{nullptr};
1873 }
1874
1875 return clientDescriptorPtr->getValue();
Keun young Parkd8973a72012-03-28 14:13:09 -07001876}
1877
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001878void CameraService::doUserSwitch(const std::vector<int32_t>& newUserIds) {
Ruben Brunk36597b22015-03-20 22:15:57 -07001879 // Acquire mServiceLock and prevent other clients from connecting
1880 std::unique_ptr<AutoConditionLock> lock =
1881 AutoConditionLock::waitAndAcquire(mServiceLockWrapper);
1882
Ruben Brunk6267b532015-04-30 17:44:07 -07001883 std::set<userid_t> newAllowedUsers;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001884 for (size_t i = 0; i < newUserIds.size(); i++) {
1885 if (newUserIds[i] < 0) {
Ruben Brunk6267b532015-04-30 17:44:07 -07001886 ALOGE("%s: Bad user ID %d given during user switch, ignoring.",
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001887 __FUNCTION__, newUserIds[i]);
Ruben Brunk6267b532015-04-30 17:44:07 -07001888 return;
1889 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001890 newAllowedUsers.insert(static_cast<userid_t>(newUserIds[i]));
Ruben Brunk36597b22015-03-20 22:15:57 -07001891 }
1892
Ruben Brunka8ca9152015-04-07 14:23:40 -07001893
Ruben Brunk6267b532015-04-30 17:44:07 -07001894 if (newAllowedUsers == mAllowedUsers) {
1895 ALOGW("%s: Received notification of user switch with no updated user IDs.", __FUNCTION__);
1896 return;
1897 }
1898
1899 logUserSwitch(mAllowedUsers, newAllowedUsers);
1900
1901 mAllowedUsers = std::move(newAllowedUsers);
Ruben Brunk36597b22015-03-20 22:15:57 -07001902
1903 // Current user has switched, evict all current clients.
1904 std::vector<sp<BasicClient>> evicted;
1905 for (auto& i : mActiveClientManager.getAll()) {
1906 auto clientSp = i->getValue();
1907
1908 if (clientSp.get() == nullptr) {
1909 ALOGE("%s: Dead client still in mActiveClientManager.", __FUNCTION__);
1910 continue;
1911 }
1912
Ruben Brunk6267b532015-04-30 17:44:07 -07001913 // Don't evict clients that are still allowed.
1914 uid_t clientUid = clientSp->getClientUid();
1915 userid_t clientUserId = multiuser_get_user_id(clientUid);
1916 if (mAllowedUsers.find(clientUserId) != mAllowedUsers.end()) {
1917 continue;
1918 }
1919
Ruben Brunk36597b22015-03-20 22:15:57 -07001920 evicted.push_back(clientSp);
1921
1922 String8 curTime = getFormattedCurrentTime();
1923
1924 ALOGE("Evicting conflicting client for camera ID %s due to user change",
1925 i->getKey().string());
Ruben Brunka8ca9152015-04-07 14:23:40 -07001926
Ruben Brunk36597b22015-03-20 22:15:57 -07001927 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07001928 logEvent(String8::format("EVICT device %s client held by package %s (PID %"
Emilian Peev8131a262017-02-01 12:33:43 +00001929 PRId32 ", score %" PRId32 ", state %" PRId32 ")\n - Evicted due"
1930 " to user switch.", i->getKey().string(),
1931 String8{clientSp->getPackageName()}.string(),
1932 i->getOwnerId(), i->getPriority().getScore(),
1933 i->getPriority().getState()));
Ruben Brunk36597b22015-03-20 22:15:57 -07001934
1935 }
1936
1937 // Do not hold mServiceLock while disconnecting clients, but retain the condition
1938 // blocking other clients from connecting in mServiceLockWrapper if held.
1939 mServiceLock.unlock();
1940
1941 // Clear caller identity temporarily so client disconnect PID checks work correctly
Jayant Chowdhary12361932018-08-27 14:46:13 -07001942 int64_t token = CameraThreadState::clearCallingIdentity();
Ruben Brunk36597b22015-03-20 22:15:57 -07001943
1944 for (auto& i : evicted) {
1945 i->disconnect();
1946 }
1947
Jayant Chowdhary12361932018-08-27 14:46:13 -07001948 CameraThreadState::restoreCallingIdentity(token);
Ruben Brunk36597b22015-03-20 22:15:57 -07001949
1950 // Reacquire mServiceLock
1951 mServiceLock.lock();
1952}
Ruben Brunkcc776712015-02-17 20:18:47 -08001953
Ruben Brunka8ca9152015-04-07 14:23:40 -07001954void CameraService::logEvent(const char* event) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001955 String8 curTime = getFormattedCurrentTime();
Ruben Brunka8ca9152015-04-07 14:23:40 -07001956 Mutex::Autolock l(mLogLock);
1957 mEventLog.add(String8::format("%s : %s", curTime.string(), event));
Mathias Agopian65ab4712010-07-14 17:59:35 -07001958}
1959
Ruben Brunka8ca9152015-04-07 14:23:40 -07001960void CameraService::logDisconnected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001961 const char* clientPackage) {
Ruben Brunkcc776712015-02-17 20:18:47 -08001962 // Log the clients evicted
Ruben Brunka8ca9152015-04-07 14:23:40 -07001963 logEvent(String8::format("DISCONNECT device %s client for package %s (PID %d)", cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001964 clientPackage, clientPid));
Ruben Brunka8ca9152015-04-07 14:23:40 -07001965}
1966
1967void CameraService::logConnected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001968 const char* clientPackage) {
Ruben Brunka8ca9152015-04-07 14:23:40 -07001969 // Log the clients evicted
1970 logEvent(String8::format("CONNECT device %s client for package %s (PID %d)", cameraId,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001971 clientPackage, clientPid));
Ruben Brunka8ca9152015-04-07 14:23:40 -07001972}
1973
1974void CameraService::logRejected(const char* cameraId, int clientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001975 const char* clientPackage, const char* reason) {
Ruben Brunka8ca9152015-04-07 14:23:40 -07001976 // Log the client rejected
1977 logEvent(String8::format("REJECT device %s client for package %s (PID %d), reason: (%s)",
Svetoslav Ganov280405a2015-05-12 02:19:27 +00001978 cameraId, clientPackage, clientPid, reason));
Ruben Brunka8ca9152015-04-07 14:23:40 -07001979}
1980
Ruben Brunk6267b532015-04-30 17:44:07 -07001981void CameraService::logUserSwitch(const std::set<userid_t>& oldUserIds,
1982 const std::set<userid_t>& newUserIds) {
1983 String8 newUsers = toString(newUserIds);
1984 String8 oldUsers = toString(oldUserIds);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001985 if (oldUsers.size() == 0) {
1986 oldUsers = "<None>";
1987 }
Ruben Brunka8ca9152015-04-07 14:23:40 -07001988 // Log the new and old users
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001989 logEvent(String8::format("USER_SWITCH previous allowed user IDs: %s, current allowed user IDs: %s",
Ruben Brunk6267b532015-04-30 17:44:07 -07001990 oldUsers.string(), newUsers.string()));
Ruben Brunka8ca9152015-04-07 14:23:40 -07001991}
1992
1993void CameraService::logDeviceRemoved(const char* cameraId, const char* reason) {
1994 // Log the device removal
1995 logEvent(String8::format("REMOVE device %s, reason: (%s)", cameraId, reason));
1996}
1997
1998void CameraService::logDeviceAdded(const char* cameraId, const char* reason) {
1999 // Log the device removal
2000 logEvent(String8::format("ADD device %s, reason: (%s)", cameraId, reason));
2001}
2002
2003void CameraService::logClientDied(int clientPid, const char* reason) {
2004 // Log the device removal
2005 logEvent(String8::format("DIED client(s) with PID %d, reason: (%s)", clientPid, reason));
Igor Murashkinecf17e82012-10-02 16:05:11 -07002006}
2007
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002008void CameraService::logServiceError(const char* msg, int errorCode) {
2009 String8 curTime = getFormattedCurrentTime();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08002010 logEvent(String8::format("SERVICE ERROR: %s : %d (%s)", msg, errorCode, strerror(-errorCode)));
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002011}
2012
Ruben Brunk36597b22015-03-20 22:15:57 -07002013status_t CameraService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
2014 uint32_t flags) {
2015
Mathias Agopian65ab4712010-07-14 17:59:35 -07002016 // Permission checks
2017 switch (code) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002018 case SHELL_COMMAND_TRANSACTION: {
2019 int in = data.readFileDescriptor();
2020 int out = data.readFileDescriptor();
2021 int err = data.readFileDescriptor();
2022 int argc = data.readInt32();
2023 Vector<String16> args;
2024 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
2025 args.add(data.readString16());
2026 }
2027 sp<IBinder> unusedCallback;
2028 sp<IResultReceiver> resultReceiver;
2029 status_t status;
2030 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
2031 return status;
2032 }
2033 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
2034 return status;
2035 }
2036 status = shellCommand(in, out, err, args);
2037 if (resultReceiver != nullptr) {
2038 resultReceiver->send(status);
2039 }
2040 return NO_ERROR;
2041 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002042 }
2043
2044 return BnCameraService::onTransact(code, data, reply, flags);
2045}
2046
Mathias Agopian65ab4712010-07-14 17:59:35 -07002047// We share the media players for shutter and recording sound for all clients.
2048// A reference count is kept to determine when we will actually release the
2049// media players.
2050
Jaekyun Seokef498052018-03-23 13:09:44 +09002051sp<MediaPlayer> CameraService::newMediaPlayer(const char *file) {
2052 sp<MediaPlayer> mp = new MediaPlayer();
2053 status_t error;
2054 if ((error = mp->setDataSource(NULL /* httpService */, file, NULL)) == NO_ERROR) {
Eino-Ville Talvala60a78ac2012-01-05 15:34:53 -08002055 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
Jaekyun Seokef498052018-03-23 13:09:44 +09002056 error = mp->prepare();
2057 }
2058 if (error != NO_ERROR) {
Steve Block29357bc2012-01-06 19:20:56 +00002059 ALOGE("Failed to load CameraService sounds: %s", file);
Jaekyun Seokef498052018-03-23 13:09:44 +09002060 mp->disconnect();
2061 mp.clear();
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002062 return nullptr;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002063 }
2064 return mp;
2065}
2066
2067void CameraService::loadSound() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002068 ATRACE_CALL();
2069
Mathias Agopian65ab4712010-07-14 17:59:35 -07002070 Mutex::Autolock lock(mSoundLock);
2071 LOG1("CameraService::loadSound ref=%d", mSoundRef);
2072 if (mSoundRef++) return;
2073
Jaekyun Seok59a8ef02018-01-15 14:49:05 +09002074 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/product/media/audio/ui/camera_click.ogg");
2075 if (mSoundPlayer[SOUND_SHUTTER] == nullptr) {
2076 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
2077 }
2078 mSoundPlayer[SOUND_RECORDING_START] = newMediaPlayer("/product/media/audio/ui/VideoRecord.ogg");
2079 if (mSoundPlayer[SOUND_RECORDING_START] == nullptr) {
2080 mSoundPlayer[SOUND_RECORDING_START] =
2081 newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
2082 }
2083 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/product/media/audio/ui/VideoStop.ogg");
2084 if (mSoundPlayer[SOUND_RECORDING_STOP] == nullptr) {
2085 mSoundPlayer[SOUND_RECORDING_STOP] = newMediaPlayer("/system/media/audio/ui/VideoStop.ogg");
2086 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002087}
2088
2089void CameraService::releaseSound() {
2090 Mutex::Autolock lock(mSoundLock);
2091 LOG1("CameraService::releaseSound ref=%d", mSoundRef);
2092 if (--mSoundRef) return;
2093
2094 for (int i = 0; i < NUM_SOUNDS; i++) {
2095 if (mSoundPlayer[i] != 0) {
2096 mSoundPlayer[i]->disconnect();
2097 mSoundPlayer[i].clear();
2098 }
2099 }
2100}
2101
2102void CameraService::playSound(sound_kind kind) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002103 ATRACE_CALL();
2104
Mathias Agopian65ab4712010-07-14 17:59:35 -07002105 LOG1("playSound(%d)", kind);
2106 Mutex::Autolock lock(mSoundLock);
2107 sp<MediaPlayer> player = mSoundPlayer[kind];
2108 if (player != 0) {
Chih-Chung Chang8888a752011-10-20 10:47:26 +08002109 player->seekTo(0);
2110 player->start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002111 }
2112}
2113
2114// ----------------------------------------------------------------------------
2115
2116CameraService::Client::Client(const sp<CameraService>& cameraService,
Wu-cheng Lib7a67942010-08-17 15:45:37 -07002117 const sp<ICameraClient>& cameraClient,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002118 const String16& clientPackageName,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002119 const String8& cameraIdStr,
2120 int api1CameraId, int cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002121 int clientPid, uid_t clientUid,
2122 int servicePid) :
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08002123 CameraService::BasicClient(cameraService,
Marco Nelissenf8880202014-11-14 07:58:25 -08002124 IInterface::asBinder(cameraClient),
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002125 clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002126 cameraIdStr, cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002127 clientPid, clientUid,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002128 servicePid),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002129 mCameraId(api1CameraId)
Igor Murashkin634a5152013-02-20 17:15:11 -08002130{
Jayant Chowdhary12361932018-08-27 14:46:13 -07002131 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002132 LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002133
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002134 mRemoteCallback = cameraClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002135
Mathias Agopian65ab4712010-07-14 17:59:35 -07002136 cameraService->loadSound();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002137
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002138 LOG1("Client::Client X (pid %d, id %d)", callingPid, mCameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002139}
2140
Mathias Agopian65ab4712010-07-14 17:59:35 -07002141// tear down the client
2142CameraService::Client::~Client() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002143 ALOGV("~Client");
Igor Murashkin634a5152013-02-20 17:15:11 -08002144 mDestructionStarted = true;
2145
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002146 sCameraService->releaseSound();
Igor Murashkin036bc3e2012-10-08 15:09:46 -07002147 // unconditionally disconnect. function is idempotent
2148 Client::disconnect();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002149}
2150
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002151sp<CameraService> CameraService::BasicClient::BasicClient::sCameraService;
2152
Igor Murashkin634a5152013-02-20 17:15:11 -08002153CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002154 const sp<IBinder>& remoteCallback,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002155 const String16& clientPackageName,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002156 const String8& cameraIdStr, int cameraFacing,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002157 int clientPid, uid_t clientUid,
2158 int servicePid):
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002159 mCameraIdStr(cameraIdStr), mCameraFacing(cameraFacing),
2160 mClientPackageName(clientPackageName), mClientPid(clientPid), mClientUid(clientUid),
2161 mServicePid(servicePid),
2162 mDisconnected(false),
2163 mRemoteBinder(remoteCallback)
Igor Murashkin634a5152013-02-20 17:15:11 -08002164{
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002165 if (sCameraService == nullptr) {
2166 sCameraService = cameraService;
2167 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002168 mOpsActive = false;
Igor Murashkin634a5152013-02-20 17:15:11 -08002169 mDestructionStarted = false;
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -08002170
2171 // In some cases the calling code has no access to the package it runs under.
2172 // For example, NDK camera API.
2173 // In this case we will get the packages for the calling UID and pick the first one
2174 // for attributing the app op. This will work correctly for runtime permissions
2175 // as for legacy apps we will toggle the app op for all packages in the UID.
2176 // The caveat is that the operation may be attributed to the wrong package and
2177 // stats based on app ops may be slightly off.
2178 if (mClientPackageName.size() <= 0) {
2179 sp<IServiceManager> sm = defaultServiceManager();
2180 sp<IBinder> binder = sm->getService(String16(kPermissionServiceName));
2181 if (binder == 0) {
2182 ALOGE("Cannot get permission service");
2183 // Leave mClientPackageName unchanged (empty) and the further interaction
2184 // with camera will fail in BasicClient::startCameraOps
2185 return;
2186 }
2187
2188 sp<IPermissionController> permCtrl = interface_cast<IPermissionController>(binder);
2189 Vector<String16> packages;
2190
2191 permCtrl->getPackagesForUid(mClientUid, packages);
2192
2193 if (packages.isEmpty()) {
2194 ALOGE("No packages for calling UID");
2195 // Leave mClientPackageName unchanged (empty) and the further interaction
2196 // with camera will fail in BasicClient::startCameraOps
2197 return;
2198 }
2199 mClientPackageName = packages[0];
2200 }
Igor Murashkin634a5152013-02-20 17:15:11 -08002201}
2202
2203CameraService::BasicClient::~BasicClient() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002204 ALOGV("~BasicClient");
Igor Murashkin634a5152013-02-20 17:15:11 -08002205 mDestructionStarted = true;
2206}
2207
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002208binder::Status CameraService::BasicClient::disconnect() {
2209 binder::Status res = Status::ok();
Ruben Brunk36597b22015-03-20 22:15:57 -07002210 if (mDisconnected) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002211 return res;
Ruben Brunk36597b22015-03-20 22:15:57 -07002212 }
Eino-Ville Talvala24901c82015-09-04 14:15:58 -07002213 mDisconnected = true;
Ruben Brunkcc776712015-02-17 20:18:47 -08002214
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002215 sCameraService->removeByClient(this);
2216 sCameraService->logDisconnected(mCameraIdStr, mClientPid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002217 String8(mClientPackageName));
Peter Kalauskasa29c1352018-10-10 12:05:42 -07002218 sCameraService->mCameraProviderManager->removeRef(CameraProviderManager::DeviceMode::CAMERA,
2219 mCameraIdStr.c_str());
Ruben Brunkcc776712015-02-17 20:18:47 -08002220
2221 sp<IBinder> remote = getRemote();
2222 if (remote != nullptr) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002223 remote->unlinkToDeath(sCameraService);
Ruben Brunkcc776712015-02-17 20:18:47 -08002224 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002225
2226 finishCameraOps();
Chien-Yu Chene4fe21b2016-08-04 12:42:40 -07002227 // Notify flashlight that a camera device is closed.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002228 sCameraService->mFlashlight->deviceClosed(mCameraIdStr);
2229 ALOGI("%s: Disconnected client for camera %s for PID %d", __FUNCTION__, mCameraIdStr.string(),
2230 mClientPid);
Ruben Brunkcc776712015-02-17 20:18:47 -08002231
Igor Murashkincba2c162013-03-20 15:56:31 -07002232 // client shouldn't be able to call into us anymore
2233 mClientPid = 0;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002234
2235 return res;
Igor Murashkin634a5152013-02-20 17:15:11 -08002236}
2237
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08002238status_t CameraService::BasicClient::dump(int, const Vector<String16>&) {
2239 // No dumping of clients directly over Binder,
2240 // must go through CameraService::dump
2241 android_errorWriteWithInfoLog(SN_EVENT_LOG_ID, "26265403",
Jayant Chowdhary12361932018-08-27 14:46:13 -07002242 CameraThreadState::getCallingUid(), NULL, 0);
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08002243 return OK;
2244}
2245
Ruben Brunkcc776712015-02-17 20:18:47 -08002246String16 CameraService::BasicClient::getPackageName() const {
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002247 return mClientPackageName;
Ruben Brunkcc776712015-02-17 20:18:47 -08002248}
2249
2250
2251int CameraService::BasicClient::getClientPid() const {
2252 return mClientPid;
2253}
2254
Ruben Brunk6267b532015-04-30 17:44:07 -07002255uid_t CameraService::BasicClient::getClientUid() const {
2256 return mClientUid;
2257}
2258
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07002259bool CameraService::BasicClient::canCastToApiClient(apiLevel level) const {
2260 // Defaults to API2.
2261 return level == API_2;
2262}
2263
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002264status_t CameraService::BasicClient::startCameraOps() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002265 ATRACE_CALL();
2266
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002267 int32_t res;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002268 // Notify app ops that the camera is not available
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002269 mOpsCallback = new OpsCallback(this);
2270
Igor Murashkine6800ce2013-03-04 17:25:57 -08002271 {
2272 ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002273 __FUNCTION__, String8(mClientPackageName).string(), mClientUid);
Igor Murashkine6800ce2013-03-04 17:25:57 -08002274 }
2275
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002276 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002277 mClientPackageName, mOpsCallback);
Svet Ganov1d519102018-02-26 10:48:14 -08002278 res = mAppOpsManager.startOpNoThrow(AppOpsManager::OP_CAMERA,
2279 mClientUid, mClientPackageName, /*startIfModeDefault*/ false);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002280
Svetoslav28e8ef72015-05-11 19:21:31 -07002281 if (res == AppOpsManager::MODE_ERRORED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002282 ALOGI("Camera %s: Access for \"%s\" has been revoked",
2283 mCameraIdStr.string(), String8(mClientPackageName).string());
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002284 return PERMISSION_DENIED;
2285 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002286
Svetoslav28e8ef72015-05-11 19:21:31 -07002287 if (res == AppOpsManager::MODE_IGNORED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002288 ALOGI("Camera %s: Access for \"%s\" has been restricted",
2289 mCameraIdStr.string(), String8(mClientPackageName).string());
Eino-Ville Talvalae3afb2c2015-06-03 16:03:30 -07002290 // Return the same error as for device policy manager rejection
2291 return -EACCES;
Svetoslav28e8ef72015-05-11 19:21:31 -07002292 }
2293
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002294 mOpsActive = true;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002295
2296 // Transition device availability listeners from PRESENT -> NOT_AVAILABLE
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002297 sCameraService->updateStatus(StatusInternal::NOT_AVAILABLE, mCameraIdStr);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002298
Emilian Peev573291c2018-02-10 02:10:56 +00002299 int apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_1;
2300 if (canCastToApiClient(API_2)) {
2301 apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_2;
2302 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002303 // Transition device state to OPEN
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002304 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
Emilian Peev573291c2018-02-10 02:10:56 +00002305 mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002306
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002307 return OK;
2308}
2309
2310status_t CameraService::BasicClient::finishCameraOps() {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002311 ATRACE_CALL();
2312
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002313 // Check if startCameraOps succeeded, and if so, finish the camera op
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002314 if (mOpsActive) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002315 // Notify app ops that the camera is available again
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002316 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002317 mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002318 mOpsActive = false;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002319
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002320 // This function is called when a client disconnects. This should
2321 // release the camera, but actually only if it was in a proper
2322 // functional state, i.e. with status NOT_AVAILABLE
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002323 std::initializer_list<StatusInternal> rejected = {StatusInternal::PRESENT,
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002324 StatusInternal::ENUMERATING, StatusInternal::NOT_PRESENT};
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002325
Ruben Brunkcc776712015-02-17 20:18:47 -08002326 // Transition to PRESENT if the camera is not in either of the rejected states
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002327 sCameraService->updateStatus(StatusInternal::PRESENT,
2328 mCameraIdStr, rejected);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002329
Emilian Peev573291c2018-02-10 02:10:56 +00002330 int apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_1;
2331 if (canCastToApiClient(API_2)) {
2332 apiLevel = hardware::ICameraServiceProxy::CAMERA_API_LEVEL_2;
2333 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07002334 // Transition device state to CLOSED
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002335 sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_CLOSED,
Emilian Peev573291c2018-02-10 02:10:56 +00002336 mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002337 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07002338 // Always stop watching, even if no camera op is active
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08002339 if (mOpsCallback != NULL) {
2340 mAppOpsManager.stopWatchingMode(mOpsCallback);
2341 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002342 mOpsCallback.clear();
2343
2344 return OK;
2345}
2346
2347void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002348 ATRACE_CALL();
2349
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002350 String8 name(packageName);
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002351 String8 myName(mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002352
2353 if (op != AppOpsManager::OP_CAMERA) {
2354 ALOGW("Unexpected app ops notification received: %d", op);
2355 return;
2356 }
2357
2358 int32_t res;
2359 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA,
Svetoslav Ganov280405a2015-05-12 02:19:27 +00002360 mClientUid, mClientPackageName);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002361 ALOGV("checkOp returns: %d, %s ", res,
2362 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" :
2363 res == AppOpsManager::MODE_IGNORED ? "IGNORED" :
2364 res == AppOpsManager::MODE_ERRORED ? "ERRORED" :
2365 "UNKNOWN");
2366
2367 if (res != AppOpsManager::MODE_ALLOWED) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002368 ALOGI("Camera %s: Access for \"%s\" revoked", mCameraIdStr.string(),
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002369 myName.string());
Svet Ganova453d0d2018-01-11 15:37:58 -08002370 block();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002371 }
2372}
2373
Svet Ganova453d0d2018-01-11 15:37:58 -08002374void CameraService::BasicClient::block() {
2375 ATRACE_CALL();
2376
2377 // Reset the client PID to allow server-initiated disconnect,
2378 // and to prevent further calls by client.
Jayant Chowdhary12361932018-08-27 14:46:13 -07002379 mClientPid = CameraThreadState::getCallingPid();
Svet Ganova453d0d2018-01-11 15:37:58 -08002380 CaptureResultExtras resultExtras; // a dummy result (invalid)
2381 notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED, resultExtras);
2382 disconnect();
2383}
2384
Mathias Agopian65ab4712010-07-14 17:59:35 -07002385// ----------------------------------------------------------------------------
2386
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002387void CameraService::Client::notifyError(int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -07002388 const CaptureResultExtras& resultExtras) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08002389 (void) resultExtras;
Ranjith Kagathi Ananda3e600892015-10-08 16:00:33 -07002390 if (mRemoteCallback != NULL) {
Yin-Chia Yehf13bda52018-05-31 12:12:59 -07002391 int32_t api1ErrorCode = CAMERA_ERROR_RELEASED;
2392 if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED) {
2393 api1ErrorCode = CAMERA_ERROR_DISABLED;
2394 }
2395 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, api1ErrorCode, 0);
Ranjith Kagathi Ananda3e600892015-10-08 16:00:33 -07002396 } else {
2397 ALOGE("mRemoteCallback is NULL!!");
2398 }
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002399}
2400
Igor Murashkin036bc3e2012-10-08 15:09:46 -07002401// NOTE: function is idempotent
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002402binder::Status CameraService::Client::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07002403 ALOGV("Client::disconnect");
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002404 return BasicClient::disconnect();
Wu-cheng Lie09591e2010-10-14 20:17:44 +08002405}
2406
Ruben Brunk0bbf8b22015-04-30 14:35:42 -07002407bool CameraService::Client::canCastToApiClient(apiLevel level) const {
2408 return level == API_1;
2409}
2410
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08002411CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client):
2412 mClient(client) {
2413}
2414
2415void CameraService::Client::OpsCallback::opChanged(int32_t op,
2416 const String16& packageName) {
2417 sp<BasicClient> client = mClient.promote();
2418 if (client != NULL) {
2419 client->opChanged(op, packageName);
2420 }
2421}
2422
Mathias Agopian65ab4712010-07-14 17:59:35 -07002423// ----------------------------------------------------------------------------
Svet Ganova453d0d2018-01-11 15:37:58 -08002424// UidPolicy
2425// ----------------------------------------------------------------------------
2426
2427void CameraService::UidPolicy::registerSelf() {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002428 Mutex::Autolock _l(mUidLock);
2429
Svet Ganova453d0d2018-01-11 15:37:58 -08002430 ActivityManager am;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002431 if (mRegistered) return;
Svet Ganova453d0d2018-01-11 15:37:58 -08002432 am.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
2433 | ActivityManager::UID_OBSERVER_IDLE
2434 | ActivityManager::UID_OBSERVER_ACTIVE,
2435 ActivityManager::PROCESS_STATE_UNKNOWN,
2436 String16("cameraserver"));
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002437 status_t res = am.linkToDeath(this);
2438 if (res == OK) {
2439 mRegistered = true;
2440 ALOGV("UidPolicy: Registered with ActivityManager");
2441 }
Svet Ganova453d0d2018-01-11 15:37:58 -08002442}
2443
2444void CameraService::UidPolicy::unregisterSelf() {
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002445 Mutex::Autolock _l(mUidLock);
2446
Svet Ganova453d0d2018-01-11 15:37:58 -08002447 ActivityManager am;
2448 am.unregisterUidObserver(this);
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002449 am.unlinkToDeath(this);
2450 mRegistered = false;
2451 mActiveUids.clear();
2452 ALOGV("UidPolicy: Unregistered with ActivityManager");
Svet Ganova453d0d2018-01-11 15:37:58 -08002453}
2454
2455void CameraService::UidPolicy::onUidGone(uid_t uid, bool disabled) {
2456 onUidIdle(uid, disabled);
2457}
2458
2459void CameraService::UidPolicy::onUidActive(uid_t uid) {
2460 Mutex::Autolock _l(mUidLock);
2461 mActiveUids.insert(uid);
2462}
2463
2464void CameraService::UidPolicy::onUidIdle(uid_t uid, bool /* disabled */) {
2465 bool deleted = false;
2466 {
2467 Mutex::Autolock _l(mUidLock);
2468 if (mActiveUids.erase(uid) > 0) {
2469 deleted = true;
2470 }
2471 }
2472 if (deleted) {
2473 sp<CameraService> service = mService.promote();
2474 if (service != nullptr) {
2475 service->blockClientsForUid(uid);
2476 }
2477 }
2478}
2479
Svet Ganov7b4ab782018-03-25 12:48:10 -07002480bool CameraService::UidPolicy::isUidActive(uid_t uid, String16 callingPackage) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002481 Mutex::Autolock _l(mUidLock);
Svet Ganov7b4ab782018-03-25 12:48:10 -07002482 return isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002483}
2484
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002485static const int64_t kPollUidActiveTimeoutTotalMillis = 300;
2486static const int64_t kPollUidActiveTimeoutMillis = 50;
Svet Ganov94ec46f2018-06-08 15:03:46 -07002487
Svet Ganov7b4ab782018-03-25 12:48:10 -07002488bool CameraService::UidPolicy::isUidActiveLocked(uid_t uid, String16 callingPackage) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002489 // Non-app UIDs are considered always active
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002490 // If activity manager is unreachable, assume everything is active
2491 if (uid < FIRST_APPLICATION_UID || !mRegistered) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002492 return true;
2493 }
2494 auto it = mOverrideUids.find(uid);
2495 if (it != mOverrideUids.end()) {
2496 return it->second;
2497 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07002498 bool active = mActiveUids.find(uid) != mActiveUids.end();
2499 if (!active) {
2500 // We want active UIDs to always access camera with their first attempt since
2501 // there is no guarantee the app is robustly written and would retry getting
2502 // the camera on failure. The inverse case is not a problem as we would take
2503 // camera away soon once we get the callback that the uid is no longer active.
2504 ActivityManager am;
2505 // Okay to access with a lock held as UID changes are dispatched without
2506 // a lock and we are a higher level component.
Svet Ganov94ec46f2018-06-08 15:03:46 -07002507 int64_t startTimeMillis = 0;
2508 do {
2509 // TODO: Fix this b/109950150!
2510 // Okay this is a hack. There is a race between the UID turning active and
2511 // activity being resumed. The proper fix is very risky, so we temporary add
2512 // some polling which should happen pretty rarely anyway as the race is hard
2513 // to hit.
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002514 active = mActiveUids.find(uid) != mActiveUids.end();
2515 if (!active) active = am.isUidActive(uid, callingPackage);
Svet Ganov94ec46f2018-06-08 15:03:46 -07002516 if (active) {
2517 break;
2518 }
2519 if (startTimeMillis <= 0) {
2520 startTimeMillis = uptimeMillis();
2521 }
2522 int64_t ellapsedTimeMillis = uptimeMillis() - startTimeMillis;
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002523 int64_t remainingTimeMillis = kPollUidActiveTimeoutTotalMillis - ellapsedTimeMillis;
Svet Ganov94ec46f2018-06-08 15:03:46 -07002524 if (remainingTimeMillis <= 0) {
2525 break;
2526 }
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002527 remainingTimeMillis = std::min(kPollUidActiveTimeoutMillis, remainingTimeMillis);
2528
2529 mUidLock.unlock();
Svet Ganov94ec46f2018-06-08 15:03:46 -07002530 usleep(remainingTimeMillis * 1000);
Eino-Ville Talvala32b8c202018-08-20 10:27:58 -07002531 mUidLock.lock();
Svet Ganov94ec46f2018-06-08 15:03:46 -07002532 } while (true);
2533
Svet Ganov7b4ab782018-03-25 12:48:10 -07002534 if (active) {
2535 // Now that we found out the UID is actually active, cache that
2536 mActiveUids.insert(uid);
2537 }
2538 }
2539 return active;
Svet Ganova453d0d2018-01-11 15:37:58 -08002540}
2541
Svet Ganov7b4ab782018-03-25 12:48:10 -07002542void CameraService::UidPolicy::UidPolicy::addOverrideUid(uid_t uid,
2543 String16 callingPackage, bool active) {
2544 updateOverrideUid(uid, callingPackage, active, true);
Svet Ganova453d0d2018-01-11 15:37:58 -08002545}
2546
Svet Ganov7b4ab782018-03-25 12:48:10 -07002547void CameraService::UidPolicy::removeOverrideUid(uid_t uid, String16 callingPackage) {
2548 updateOverrideUid(uid, callingPackage, false, false);
Svet Ganova453d0d2018-01-11 15:37:58 -08002549}
2550
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -07002551void CameraService::UidPolicy::binderDied(const wp<IBinder>& /*who*/) {
2552 Mutex::Autolock _l(mUidLock);
2553 ALOGV("UidPolicy: ActivityManager has died");
2554 mRegistered = false;
2555 mActiveUids.clear();
2556}
2557
Svet Ganov7b4ab782018-03-25 12:48:10 -07002558void CameraService::UidPolicy::updateOverrideUid(uid_t uid, String16 callingPackage,
2559 bool active, bool insert) {
Svet Ganova453d0d2018-01-11 15:37:58 -08002560 bool wasActive = false;
2561 bool isActive = false;
2562 {
2563 Mutex::Autolock _l(mUidLock);
Svet Ganov7b4ab782018-03-25 12:48:10 -07002564 wasActive = isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002565 mOverrideUids.erase(uid);
2566 if (insert) {
2567 mOverrideUids.insert(std::pair<uid_t, bool>(uid, active));
2568 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07002569 isActive = isUidActiveLocked(uid, callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -08002570 }
2571 if (wasActive != isActive && !isActive) {
2572 sp<CameraService> service = mService.promote();
2573 if (service != nullptr) {
2574 service->blockClientsForUid(uid);
2575 }
2576 }
2577}
2578
2579// ----------------------------------------------------------------------------
Ruben Brunkcc776712015-02-17 20:18:47 -08002580// CameraState
2581// ----------------------------------------------------------------------------
2582
2583CameraService::CameraState::CameraState(const String8& id, int cost,
2584 const std::set<String8>& conflicting) : mId(id),
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +01002585 mStatus(StatusInternal::NOT_PRESENT), mCost(cost), mConflicting(conflicting) {}
Ruben Brunkcc776712015-02-17 20:18:47 -08002586
2587CameraService::CameraState::~CameraState() {}
2588
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002589CameraService::StatusInternal CameraService::CameraState::getStatus() const {
Ruben Brunkcc776712015-02-17 20:18:47 -08002590 Mutex::Autolock lock(mStatusLock);
2591 return mStatus;
2592}
2593
2594CameraParameters CameraService::CameraState::getShimParams() const {
2595 return mShimParams;
2596}
2597
2598void CameraService::CameraState::setShimParams(const CameraParameters& params) {
2599 mShimParams = params;
2600}
2601
2602int CameraService::CameraState::getCost() const {
2603 return mCost;
2604}
2605
2606std::set<String8> CameraService::CameraState::getConflicting() const {
2607 return mConflicting;
2608}
2609
2610String8 CameraService::CameraState::getId() const {
2611 return mId;
2612}
2613
2614// ----------------------------------------------------------------------------
Ruben Brunk99e69712015-05-26 17:25:07 -07002615// ClientEventListener
2616// ----------------------------------------------------------------------------
2617
2618void CameraService::ClientEventListener::onClientAdded(
2619 const resource_policy::ClientDescriptor<String8,
2620 sp<CameraService::BasicClient>>& descriptor) {
Chih-Hung Hsieh5404ee12016-08-09 14:25:53 -07002621 const auto& basicClient = descriptor.getValue();
Ruben Brunk99e69712015-05-26 17:25:07 -07002622 if (basicClient.get() != nullptr) {
2623 BatteryNotifier& notifier(BatteryNotifier::getInstance());
2624 notifier.noteStartCamera(descriptor.getKey(),
2625 static_cast<int>(basicClient->getClientUid()));
2626 }
2627}
2628
2629void CameraService::ClientEventListener::onClientRemoved(
2630 const resource_policy::ClientDescriptor<String8,
2631 sp<CameraService::BasicClient>>& descriptor) {
Chih-Hung Hsieh5404ee12016-08-09 14:25:53 -07002632 const auto& basicClient = descriptor.getValue();
Ruben Brunk99e69712015-05-26 17:25:07 -07002633 if (basicClient.get() != nullptr) {
2634 BatteryNotifier& notifier(BatteryNotifier::getInstance());
2635 notifier.noteStopCamera(descriptor.getKey(),
2636 static_cast<int>(basicClient->getClientUid()));
2637 }
2638}
2639
2640
2641// ----------------------------------------------------------------------------
Ruben Brunkcc776712015-02-17 20:18:47 -08002642// CameraClientManager
2643// ----------------------------------------------------------------------------
2644
Ruben Brunk99e69712015-05-26 17:25:07 -07002645CameraService::CameraClientManager::CameraClientManager() {
2646 setListener(std::make_shared<ClientEventListener>());
2647}
2648
Ruben Brunkcc776712015-02-17 20:18:47 -08002649CameraService::CameraClientManager::~CameraClientManager() {}
2650
2651sp<CameraService::BasicClient> CameraService::CameraClientManager::getCameraClient(
2652 const String8& id) const {
2653 auto descriptor = get(id);
2654 if (descriptor == nullptr) {
2655 return sp<BasicClient>{nullptr};
2656 }
2657 return descriptor->getValue();
2658}
2659
2660String8 CameraService::CameraClientManager::toString() const {
2661 auto all = getAll();
2662 String8 ret("[");
2663 bool hasAny = false;
2664 for (auto& i : all) {
2665 hasAny = true;
2666 String8 key = i->getKey();
2667 int32_t cost = i->getCost();
2668 int32_t pid = i->getOwnerId();
Emilian Peev8131a262017-02-01 12:33:43 +00002669 int32_t score = i->getPriority().getScore();
2670 int32_t state = i->getPriority().getState();
Ruben Brunkcc776712015-02-17 20:18:47 -08002671 auto conflicting = i->getConflicting();
2672 auto clientSp = i->getValue();
2673 String8 packageName;
Eino-Ville Talvala022f0cb2015-05-19 16:31:16 -07002674 userid_t clientUserId = 0;
Ruben Brunkcc776712015-02-17 20:18:47 -08002675 if (clientSp.get() != nullptr) {
2676 packageName = String8{clientSp->getPackageName()};
Ruben Brunk6267b532015-04-30 17:44:07 -07002677 uid_t clientUid = clientSp->getClientUid();
2678 clientUserId = multiuser_get_user_id(clientUid);
Ruben Brunkcc776712015-02-17 20:18:47 -08002679 }
Emilian Peev8131a262017-02-01 12:33:43 +00002680 ret.appendFormat("\n(Camera ID: %s, Cost: %" PRId32 ", PID: %" PRId32 ", Score: %"
2681 PRId32 ", State: %" PRId32, key.string(), cost, pid, score, state);
Ruben Brunkcc776712015-02-17 20:18:47 -08002682
Ruben Brunk6267b532015-04-30 17:44:07 -07002683 if (clientSp.get() != nullptr) {
2684 ret.appendFormat("User Id: %d, ", clientUserId);
2685 }
Ruben Brunkcc776712015-02-17 20:18:47 -08002686 if (packageName.size() != 0) {
2687 ret.appendFormat("Client Package Name: %s", packageName.string());
2688 }
2689
2690 ret.append(", Conflicting Client Devices: {");
2691 for (auto& j : conflicting) {
2692 ret.appendFormat("%s, ", j.string());
2693 }
2694 ret.append("})");
2695 }
2696 if (hasAny) ret.append("\n");
2697 ret.append("]\n");
2698 return ret;
2699}
2700
2701CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2702 const String8& key, const sp<BasicClient>& value, int32_t cost,
Emilian Peev8131a262017-02-01 12:33:43 +00002703 const std::set<String8>& conflictingKeys, int32_t score, int32_t ownerId,
2704 int32_t state) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002705
2706 return std::make_shared<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>(
Emilian Peev8131a262017-02-01 12:33:43 +00002707 key, value, cost, conflictingKeys, score, ownerId, state);
Ruben Brunkcc776712015-02-17 20:18:47 -08002708}
2709
2710CameraService::DescriptorPtr CameraService::CameraClientManager::makeClientDescriptor(
2711 const sp<BasicClient>& value, const CameraService::DescriptorPtr& partial) {
2712 return makeClientDescriptor(partial->getKey(), value, partial->getCost(),
Emilian Peev8131a262017-02-01 12:33:43 +00002713 partial->getConflicting(), partial->getPriority().getScore(),
2714 partial->getOwnerId(), partial->getPriority().getState());
Ruben Brunkcc776712015-02-17 20:18:47 -08002715}
2716
2717// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -07002718
2719static const int kDumpLockRetries = 50;
2720static const int kDumpLockSleep = 60000;
2721
2722static bool tryLock(Mutex& mutex)
2723{
2724 bool locked = false;
2725 for (int i = 0; i < kDumpLockRetries; ++i) {
2726 if (mutex.tryLock() == NO_ERROR) {
2727 locked = true;
2728 break;
2729 }
2730 usleep(kDumpLockSleep);
2731 }
2732 return locked;
2733}
2734
2735status_t CameraService::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalaa84bbe62015-09-08 17:59:17 -07002736 ATRACE_CALL();
2737
Mathias Agopian65ab4712010-07-14 17:59:35 -07002738 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002739 dprintf(fd, "Permission Denial: can't dump CameraService from pid=%d, uid=%d\n",
Jayant Chowdhary12361932018-08-27 14:46:13 -07002740 CameraThreadState::getCallingPid(),
2741 CameraThreadState::getCallingUid());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002742 return NO_ERROR;
2743 }
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002744 bool locked = tryLock(mServiceLock);
2745 // failed to lock - CameraService is probably deadlocked
2746 if (!locked) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002747 dprintf(fd, "!! CameraService may be deadlocked !!\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002748 }
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002749
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002750 if (!mInitialized) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002751 dprintf(fd, "!! No camera HAL available !!\n");
Ruben Brunkf81648e2014-04-17 16:14:57 -07002752
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002753 // Dump event log for error information
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002754 dumpEventLog(fd);
Ruben Brunkcc776712015-02-17 20:18:47 -08002755
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002756 if (locked) mServiceLock.unlock();
2757 return NO_ERROR;
2758 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002759 dprintf(fd, "\n== Service global info: ==\n\n");
2760 dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08002761 dprintf(fd, "Number of normal camera devices: %zu\n", mNormalDeviceIds.size());
2762 for (size_t i = 0; i < mNormalDeviceIds.size(); i++) {
2763 dprintf(fd, " Device %zu maps to \"%s\"\n", i, mNormalDeviceIds[i].c_str());
2764 }
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002765 String8 activeClientString = mActiveClientManager.toString();
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002766 dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());
2767 dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002768
2769 dumpEventLog(fd);
2770
2771 bool stateLocked = tryLock(mCameraStatesLock);
2772 if (!stateLocked) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002773 dprintf(fd, "CameraStates in use, may be deadlocked\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002774 }
2775
Emilian Peevbd8c5032018-02-14 23:05:40 +00002776 int argSize = args.size();
2777 for (int i = 0; i < argSize; i++) {
2778 if (args[i] == TagMonitor::kMonitorOption) {
2779 if (i + 1 < argSize) {
2780 mMonitorTags = String8(args[i + 1]);
2781 }
2782 break;
2783 }
2784 }
2785
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002786 for (auto& state : mCameraStates) {
2787 String8 cameraId = state.first;
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002788
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002789 dprintf(fd, "== Camera device %s dynamic info: ==\n", cameraId.string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002790
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002791 CameraParameters p = state.second->getShimParams();
2792 if (!p.isEmpty()) {
2793 dprintf(fd, " Camera1 API shim is using parameters:\n ");
2794 p.dump(fd, args);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002795 }
2796
2797 auto clientDescriptor = mActiveClientManager.get(cameraId);
Zhijun He2f140ed2017-02-08 09:57:23 -08002798 if (clientDescriptor != nullptr) {
2799 dprintf(fd, " Device %s is open. Client instance dump:\n",
2800 cameraId.string());
2801 dprintf(fd, " Client priority score: %d state: %d\n",
2802 clientDescriptor->getPriority().getScore(),
2803 clientDescriptor->getPriority().getState());
2804 dprintf(fd, " Client PID: %d\n", clientDescriptor->getOwnerId());
2805
2806 auto client = clientDescriptor->getValue();
2807 dprintf(fd, " Client package: %s\n",
2808 String8(client->getPackageName()).string());
2809
2810 client->dumpClient(fd, args);
2811 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002812 dprintf(fd, " Device %s is closed, no client instance\n",
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002813 cameraId.string());
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002814 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002815
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002816 }
2817
2818 if (stateLocked) mCameraStatesLock.unlock();
2819
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002820 if (locked) mServiceLock.unlock();
2821
Emilian Peevf53f66e2017-04-11 14:29:43 +01002822 mCameraProviderManager->dump(fd, args);
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002823
2824 dprintf(fd, "\n== Vendor tags: ==\n\n");
2825
2826 sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
2827 if (desc == NULL) {
Emilian Peev71c73a22017-03-21 16:35:51 +00002828 sp<VendorTagDescriptorCache> cache =
2829 VendorTagDescriptorCache::getGlobalVendorTagCache();
2830 if (cache == NULL) {
2831 dprintf(fd, "No vendor tags.\n");
2832 } else {
2833 cache->dump(fd, /*verbosity*/2, /*indentation*/2);
2834 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002835 } else {
2836 desc->dump(fd, /*verbosity*/2, /*indentation*/2);
2837 }
2838
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002839 // Dump camera traces if there were any
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002840 dprintf(fd, "\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002841 camera3::CameraTraces::dump(fd, args);
2842
2843 // Process dump arguments, if any
2844 int n = args.size();
2845 String16 verboseOption("-v");
2846 String16 unreachableOption("--unreachable");
2847 for (int i = 0; i < n; i++) {
2848 if (args[i] == verboseOption) {
2849 // change logging level
2850 if (i + 1 >= n) continue;
2851 String8 levelStr(args[i+1]);
2852 int level = atoi(levelStr.string());
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002853 dprintf(fd, "\nSetting log level to %d.\n", level);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002854 setLogLevel(level);
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002855 } else if (args[i] == unreachableOption) {
2856 // Dump memory analysis
2857 // TODO - should limit be an argument parameter?
2858 UnreachableMemoryInfo info;
2859 bool success = GetUnreachableMemory(info, /*limit*/ 10000);
2860 if (!success) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002861 dprintf(fd, "\n== Unable to dump unreachable memory. "
2862 "Try disabling SELinux enforcement. ==\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002863 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002864 dprintf(fd, "\n== Dumping unreachable memory: ==\n");
Eino-Ville Talvala81314182017-01-30 16:13:45 -08002865 std::string s = info.ToString(/*log_contents*/ true);
2866 write(fd, s.c_str(), s.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002867 }
2868 }
2869 }
2870 return NO_ERROR;
2871}
2872
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002873void CameraService::dumpEventLog(int fd) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002874 dprintf(fd, "\n== Camera service events log (most recent at top): ==\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002875
2876 Mutex::Autolock l(mLogLock);
2877 for (const auto& msg : mEventLog) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002878 dprintf(fd, " %s\n", msg.string());
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002879 }
2880
2881 if (mEventLog.size() == DEFAULT_EVENT_LOG_LENGTH) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002882 dprintf(fd, " ...\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002883 } else if (mEventLog.size() == 0) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002884 dprintf(fd, " [no events yet]\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002885 }
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08002886 dprintf(fd, "\n");
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07002887}
2888
Chien-Yu Chen3068d732015-02-09 13:29:57 -08002889void CameraService::handleTorchClientBinderDied(const wp<IBinder> &who) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08002890 Mutex::Autolock al(mTorchClientMapMutex);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08002891 for (size_t i = 0; i < mTorchClientMap.size(); i++) {
2892 if (mTorchClientMap[i] == who) {
2893 // turn off the torch mode that was turned on by dead client
Chien-Yu Chen88da5262015-02-17 13:56:46 -08002894 String8 cameraId = mTorchClientMap.keyAt(i);
2895 status_t res = mFlashlight->setTorchMode(cameraId, false);
2896 if (res) {
2897 ALOGE("%s: torch client died but couldn't turn off torch: "
2898 "%s (%d)", __FUNCTION__, strerror(-res), res);
2899 return;
2900 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08002901 mTorchClientMap.removeItemsAt(i);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08002902 break;
2903 }
2904 }
2905}
2906
Ruben Brunkcc776712015-02-17 20:18:47 -08002907/*virtual*/void CameraService::binderDied(const wp<IBinder> &who) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07002908
Igor Murashkin294d0ec2012-10-05 10:44:57 -07002909 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07002910 * While tempting to promote the wp<IBinder> into a sp, it's actually not supported by the
2911 * binder driver
Igor Murashkin294d0ec2012-10-05 10:44:57 -07002912 */
Yin-Chia Yehdbfcb382018-02-16 11:17:36 -08002913 // PID here is approximate and can be wrong.
Jayant Chowdhary12361932018-08-27 14:46:13 -07002914 logClientDied(CameraThreadState::getCallingPid(), String8("Binder died unexpectedly"));
Ruben Brunka8ca9152015-04-07 14:23:40 -07002915
Chien-Yu Chen3068d732015-02-09 13:29:57 -08002916 // check torch client
2917 handleTorchClientBinderDied(who);
2918
2919 // check camera device client
Ruben Brunkcc776712015-02-17 20:18:47 -08002920 if(!evictClientIdByRemote(who)) {
2921 ALOGV("%s: Java client's binder death already cleaned up (normal case)", __FUNCTION__);
Igor Murashkinecf17e82012-10-02 16:05:11 -07002922 return;
2923 }
2924
Ruben Brunkcc776712015-02-17 20:18:47 -08002925 ALOGE("%s: Java client's binder died, removing it from the list of active clients",
2926 __FUNCTION__);
Igor Murashkinecf17e82012-10-02 16:05:11 -07002927}
2928
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002929void CameraService::updateStatus(StatusInternal status, const String8& cameraId) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002930 updateStatus(status, cameraId, {});
Igor Murashkinbfc99152013-02-27 12:55:20 -08002931}
2932
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002933void CameraService::updateStatus(StatusInternal status, const String8& cameraId,
2934 std::initializer_list<StatusInternal> rejectSourceStates) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002935 // Do not lock mServiceLock here or can get into a deadlock from
2936 // connect() -> disconnect -> updateStatus
2937
2938 auto state = getCameraState(cameraId);
2939
2940 if (state == nullptr) {
2941 ALOGW("%s: Could not update the status for %s, no such device exists", __FUNCTION__,
2942 cameraId.string());
2943 return;
Igor Murashkincba2c162013-03-20 15:56:31 -07002944 }
2945
Ruben Brunkcc776712015-02-17 20:18:47 -08002946 // Update the status for this camera state, then send the onStatusChangedCallbacks to each
2947 // of the listeners with both the mStatusStatus and mStatusListenerLock held
2948 state->updateStatus(status, cameraId, rejectSourceStates, [this]
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002949 (const String8& cameraId, StatusInternal status) {
Ruben Brunkcc776712015-02-17 20:18:47 -08002950
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002951 if (status != StatusInternal::ENUMERATING) {
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07002952 // Update torch status if it has a flash unit.
2953 Mutex::Autolock al(mTorchStatusMutex);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002954 TorchModeStatus torchStatus;
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07002955 if (getTorchStatusLocked(cameraId, &torchStatus) !=
2956 NAME_NOT_FOUND) {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002957 TorchModeStatus newTorchStatus =
2958 status == StatusInternal::PRESENT ?
2959 TorchModeStatus::AVAILABLE_OFF :
2960 TorchModeStatus::NOT_AVAILABLE;
Chien-Yu Chenf6463fc2015-04-07 15:11:31 -07002961 if (torchStatus != newTorchStatus) {
2962 onTorchStatusChangedLocked(cameraId, newTorchStatus);
2963 }
2964 }
Ruben Brunkcc776712015-02-17 20:18:47 -08002965 }
2966
2967 Mutex::Autolock lock(mStatusListenerLock);
2968
2969 for (auto& listener : mListenerList) {
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002970 listener->onStatusChanged(mapToInterface(status), String16(cameraId));
Ruben Brunkcc776712015-02-17 20:18:47 -08002971 }
2972 });
Igor Murashkincba2c162013-03-20 15:56:31 -07002973}
2974
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08002975template<class Func>
2976void CameraService::CameraState::updateStatus(StatusInternal status,
2977 const String8& cameraId,
2978 std::initializer_list<StatusInternal> rejectSourceStates,
2979 Func onStatusUpdatedLocked) {
2980 Mutex::Autolock lock(mStatusLock);
2981 StatusInternal oldStatus = mStatus;
2982 mStatus = status;
2983
2984 if (oldStatus == status) {
2985 return;
2986 }
2987
2988 ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
2989 cameraId.string(), oldStatus, status);
2990
2991 if (oldStatus == StatusInternal::NOT_PRESENT &&
2992 (status != StatusInternal::PRESENT &&
2993 status != StatusInternal::ENUMERATING)) {
2994
2995 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
2996 __FUNCTION__);
2997 mStatus = oldStatus;
2998 return;
2999 }
3000
3001 /**
3002 * Sometimes we want to conditionally do a transition.
3003 * For example if a client disconnects, we want to go to PRESENT
3004 * only if we weren't already in NOT_PRESENT or ENUMERATING.
3005 */
3006 for (auto& rejectStatus : rejectSourceStates) {
3007 if (oldStatus == rejectStatus) {
3008 ALOGV("%s: Rejecting status transition for Camera ID %s, since the source "
3009 "state was was in one of the bad states.", __FUNCTION__, cameraId.string());
3010 mStatus = oldStatus;
3011 return;
3012 }
3013 }
3014
3015 onStatusUpdatedLocked(cameraId, status);
3016}
3017
Eino-Ville Talvalae8c96c72017-06-27 12:24:07 -07003018void CameraService::updateProxyDeviceState(int newState,
Emilian Peev573291c2018-02-10 02:10:56 +00003019 const String8& cameraId, int facing, const String16& clientName, int apiLevel) {
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07003020 sp<ICameraServiceProxy> proxyBinder = getCameraServiceProxy();
3021 if (proxyBinder == nullptr) return;
3022 String16 id(cameraId);
Emilian Peev573291c2018-02-10 02:10:56 +00003023 proxyBinder->notifyCameraState(id, newState, facing, clientName, apiLevel);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07003024}
3025
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003026status_t CameraService::getTorchStatusLocked(
3027 const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003028 TorchModeStatus *status) const {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003029 if (!status) {
3030 return BAD_VALUE;
3031 }
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003032 ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3033 if (index == NAME_NOT_FOUND) {
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003034 // invalid camera ID or the camera doesn't have a flash unit
3035 return NAME_NOT_FOUND;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003036 }
3037
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003038 *status = mTorchStatusMap.valueAt(index);
3039 return OK;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003040}
3041
Chien-Yu Chen88da5262015-02-17 13:56:46 -08003042status_t CameraService::setTorchStatusLocked(const String8& cameraId,
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003043 TorchModeStatus status) {
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003044 ssize_t index = mTorchStatusMap.indexOfKey(cameraId);
3045 if (index == NAME_NOT_FOUND) {
3046 return BAD_VALUE;
3047 }
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08003048 mTorchStatusMap.editValueAt(index) = status;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08003049
3050 return OK;
3051}
3052
Svet Ganova453d0d2018-01-11 15:37:58 -08003053void CameraService::blockClientsForUid(uid_t uid) {
3054 const auto clients = mActiveClientManager.getAll();
3055 for (auto& current : clients) {
3056 if (current != nullptr) {
3057 const auto basicClient = current->getValue();
3058 if (basicClient.get() != nullptr && basicClient->getClientUid() == uid) {
3059 basicClient->block();
3060 }
3061 }
3062 }
3063}
3064
3065// NOTE: This is a remote API - make sure all args are validated
3066status_t CameraService::shellCommand(int in, int out, int err, const Vector<String16>& args) {
3067 if (!checkCallingPermission(sManageCameraPermission, nullptr, nullptr)) {
3068 return PERMISSION_DENIED;
3069 }
3070 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
3071 return BAD_VALUE;
3072 }
3073 if (args.size() == 3 && args[0] == String16("set-uid-state")) {
3074 return handleSetUidState(args, err);
3075 } else if (args.size() == 2 && args[0] == String16("reset-uid-state")) {
3076 return handleResetUidState(args, err);
3077 } else if (args.size() == 2 && args[0] == String16("get-uid-state")) {
3078 return handleGetUidState(args, out, err);
3079 } else if (args.size() == 1 && args[0] == String16("help")) {
3080 printHelp(out);
3081 return NO_ERROR;
3082 }
3083 printHelp(err);
3084 return BAD_VALUE;
3085}
3086
3087status_t CameraService::handleSetUidState(const Vector<String16>& args, int err) {
3088 PermissionController pc;
3089 int uid = pc.getPackageUid(args[1], 0);
3090 if (uid <= 0) {
3091 ALOGE("Unknown package: '%s'", String8(args[1]).string());
3092 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
3093 return BAD_VALUE;
3094 }
3095 bool active = false;
3096 if (args[2] == String16("active")) {
3097 active = true;
3098 } else if ((args[2] != String16("idle"))) {
3099 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
3100 return BAD_VALUE;
3101 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07003102 mUidPolicy->addOverrideUid(uid, args[1], active);
Svet Ganova453d0d2018-01-11 15:37:58 -08003103 return NO_ERROR;
3104}
3105
3106status_t CameraService::handleResetUidState(const Vector<String16>& args, int err) {
3107 PermissionController pc;
3108 int uid = pc.getPackageUid(args[1], 0);
3109 if (uid < 0) {
3110 ALOGE("Unknown package: '%s'", String8(args[1]).string());
3111 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
3112 return BAD_VALUE;
3113 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07003114 mUidPolicy->removeOverrideUid(uid, args[1]);
Svet Ganova453d0d2018-01-11 15:37:58 -08003115 return NO_ERROR;
3116}
3117
3118status_t CameraService::handleGetUidState(const Vector<String16>& args, int out, int err) {
3119 PermissionController pc;
3120 int uid = pc.getPackageUid(args[1], 0);
3121 if (uid <= 0) {
3122 ALOGE("Unknown package: '%s'", String8(args[1]).string());
3123 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
3124 return BAD_VALUE;
3125 }
Svet Ganov7b4ab782018-03-25 12:48:10 -07003126 if (mUidPolicy->isUidActive(uid, args[1])) {
Svet Ganova453d0d2018-01-11 15:37:58 -08003127 return dprintf(out, "active\n");
3128 } else {
3129 return dprintf(out, "idle\n");
3130 }
3131}
3132
3133status_t CameraService::printHelp(int out) {
3134 return dprintf(out, "Camera service commands:\n"
3135 " get-uid-state <PACKAGE> gets the uid state\n"
3136 " set-uid-state <PACKAGE> <active|idle> overrides the uid state\n"
3137 " reset-uid-state <PACKAGE> clears the uid state override\n"
3138 " help print this message\n");
3139}
3140
Mathias Agopian65ab4712010-07-14 17:59:35 -07003141}; // namespace android