blob: fd5a426acaa5fdd2dda0b9afb98ea11281c353d8 [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"
Iliyan Malchev8951a972011-04-14 16:55:59 -070018//#define LOG_NDEBUG 0
Mathias Agopian65ab4712010-07-14 17:59:35 -070019
20#include <stdio.h>
Ruben Brunkd1176ef2014-02-21 10:51:38 -080021#include <string.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070022#include <sys/types.h>
23#include <pthread.h>
24
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080025#include <binder/AppOpsManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070026#include <binder/IPCThreadState.h>
27#include <binder/IServiceManager.h>
28#include <binder/MemoryBase.h>
29#include <binder/MemoryHeapBase.h>
30#include <cutils/atomic.h>
Nipun Kwatrab5ca4612010-09-11 19:31:10 -070031#include <cutils/properties.h>
Mathias Agopiandf712ea2012-02-25 18:48:35 -080032#include <gui/Surface.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070033#include <hardware/hardware.h>
34#include <media/AudioSystem.h>
Andreas Huber1b86fe02014-01-29 11:13:26 -080035#include <media/IMediaHTTPService.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070036#include <media/mediaplayer.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070037#include <utils/Errors.h>
38#include <utils/Log.h>
39#include <utils/String16.h>
Ruben Brunkd1176ef2014-02-21 10:51:38 -080040#include <utils/Trace.h>
41#include <system/camera_vendor_tags.h>
Ruben Brunkb2119af2014-05-09 19:57:56 -070042#include <system/camera_metadata.h>
43#include <system/camera.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070044
45#include "CameraService.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070046#include "api1/CameraClient.h"
47#include "api1/Camera2Client.h"
48#include "api_pro/ProCamera2Client.h"
49#include "api2/CameraDeviceClient.h"
Igor Murashkinff3e31d2013-10-23 16:40:06 -070050#include "utils/CameraTraces.h"
Igor Murashkin98e24722013-06-19 19:51:04 -070051#include "CameraDeviceFactory.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070052
53namespace android {
54
55// ----------------------------------------------------------------------------
56// Logging support -- this is for debugging only
57// Use "adb shell dumpsys media.camera -v 1" to change it.
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -070058volatile int32_t gLogLevel = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -070059
Steve Blockb8a80522011-12-20 16:23:08 +000060#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
61#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
Mathias Agopian65ab4712010-07-14 17:59:35 -070062
63static void setLogLevel(int level) {
64 android_atomic_write(level, &gLogLevel);
65}
66
67// ----------------------------------------------------------------------------
68
69static int getCallingPid() {
70 return IPCThreadState::self()->getCallingPid();
71}
72
73static int getCallingUid() {
74 return IPCThreadState::self()->getCallingUid();
75}
76
Igor Murashkincba2c162013-03-20 15:56:31 -070077extern "C" {
78static void camera_device_status_change(
79 const struct camera_module_callbacks* callbacks,
80 int camera_id,
81 int new_status) {
82 sp<CameraService> cs = const_cast<CameraService*>(
83 static_cast<const CameraService*>(callbacks));
84
85 cs->onDeviceStatusChanged(
86 camera_id,
87 new_status);
88}
89} // extern "C"
90
Mathias Agopian65ab4712010-07-14 17:59:35 -070091// ----------------------------------------------------------------------------
92
93// This is ugly and only safe if we never re-create the CameraService, but
94// should be ok for now.
95static CameraService *gCameraService;
96
97CameraService::CameraService()
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080098 :mSoundRef(0), mModule(0)
Mathias Agopian65ab4712010-07-14 17:59:35 -070099{
Steve Blockdf64d152012-01-04 20:05:49 +0000100 ALOGI("CameraService started (pid=%d)", getpid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700101 gCameraService = this;
Igor Murashkinbfc99152013-02-27 12:55:20 -0800102
103 for (size_t i = 0; i < MAX_CAMERAS; ++i) {
Igor Murashkincba2c162013-03-20 15:56:31 -0700104 mStatusList[i] = ICameraServiceListener::STATUS_PRESENT;
Igor Murashkinbfc99152013-02-27 12:55:20 -0800105 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700106
107 this->camera_device_status_change = android::camera_device_status_change;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700108}
109
Iliyan Malchev8951a972011-04-14 16:55:59 -0700110void CameraService::onFirstRef()
111{
Igor Murashkin634a5152013-02-20 17:15:11 -0800112 LOG1("CameraService::onFirstRef");
113
Iliyan Malchev8951a972011-04-14 16:55:59 -0700114 BnCameraService::onFirstRef();
115
116 if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
117 (const hw_module_t **)&mModule) < 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000118 ALOGE("Could not load camera HAL module");
Iliyan Malchev8951a972011-04-14 16:55:59 -0700119 mNumberOfCameras = 0;
120 }
121 else {
Alex Rayc0dd54f2013-02-20 13:39:37 -0800122 ALOGI("Loaded \"%s\" camera module", mModule->common.name);
Iliyan Malchev8951a972011-04-14 16:55:59 -0700123 mNumberOfCameras = mModule->get_number_of_cameras();
124 if (mNumberOfCameras > MAX_CAMERAS) {
Steve Block29357bc2012-01-06 19:20:56 +0000125 ALOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
Iliyan Malchev8951a972011-04-14 16:55:59 -0700126 mNumberOfCameras, MAX_CAMERAS);
127 mNumberOfCameras = MAX_CAMERAS;
128 }
129 for (int i = 0; i < mNumberOfCameras; i++) {
130 setCameraFree(i);
131 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700132
133 if (mModule->common.module_api_version >=
134 CAMERA_MODULE_API_VERSION_2_1) {
135 mModule->set_callbacks(this);
136 }
Igor Murashkin98e24722013-06-19 19:51:04 -0700137
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800138 VendorTagDescriptor::clearGlobalVendorTagDescriptor();
139
140 if (mModule->common.module_api_version >= CAMERA_MODULE_API_VERSION_2_2) {
141 setUpVendorTags();
142 }
143
Igor Murashkin98e24722013-06-19 19:51:04 -0700144 CameraDeviceFactory::registerService(this);
Iliyan Malchev8951a972011-04-14 16:55:59 -0700145 }
146}
147
Mathias Agopian65ab4712010-07-14 17:59:35 -0700148CameraService::~CameraService() {
149 for (int i = 0; i < mNumberOfCameras; i++) {
150 if (mBusy[i]) {
Steve Block29357bc2012-01-06 19:20:56 +0000151 ALOGE("camera %d is still in use in destructor!", i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700152 }
153 }
154
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800155 VendorTagDescriptor::clearGlobalVendorTagDescriptor();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700156 gCameraService = NULL;
157}
158
Igor Murashkincba2c162013-03-20 15:56:31 -0700159void CameraService::onDeviceStatusChanged(int cameraId,
160 int newStatus)
161{
162 ALOGI("%s: Status changed for cameraId=%d, newStatus=%d", __FUNCTION__,
163 cameraId, newStatus);
164
165 if (cameraId < 0 || cameraId >= MAX_CAMERAS) {
166 ALOGE("%s: Bad camera ID %d", __FUNCTION__, cameraId);
167 return;
168 }
169
170 if ((int)getStatus(cameraId) == newStatus) {
171 ALOGE("%s: State transition to the same status 0x%x not allowed",
172 __FUNCTION__, (uint32_t)newStatus);
173 return;
174 }
175
176 /* don't do this in updateStatus
177 since it is also called from connect and we could get into a deadlock */
178 if (newStatus == CAMERA_DEVICE_STATUS_NOT_PRESENT) {
179 Vector<sp<BasicClient> > clientsToDisconnect;
180 {
181 Mutex::Autolock al(mServiceLock);
182
Ruben Brunkb2119af2014-05-09 19:57:56 -0700183 /* Remove cached parameters from shim cache */
184 mShimParams.removeItem(cameraId);
185
Igor Murashkincba2c162013-03-20 15:56:31 -0700186 /* Find all clients that we need to disconnect */
Igor Murashkine7ee7632013-06-11 18:10:18 -0700187 sp<BasicClient> client = mClient[cameraId].promote();
Igor Murashkincba2c162013-03-20 15:56:31 -0700188 if (client.get() != NULL) {
189 clientsToDisconnect.push_back(client);
190 }
191
192 int i = cameraId;
193 for (size_t j = 0; j < mProClientList[i].size(); ++j) {
194 sp<ProClient> cl = mProClientList[i][j].promote();
195 if (cl != NULL) {
196 clientsToDisconnect.push_back(cl);
197 }
198 }
199 }
200
201 /* now disconnect them. don't hold the lock
202 or we can get into a deadlock */
203
204 for (size_t i = 0; i < clientsToDisconnect.size(); ++i) {
205 sp<BasicClient> client = clientsToDisconnect[i];
206
207 client->disconnect();
208 /**
209 * The remote app will no longer be able to call methods on the
210 * client since the client PID will be reset to 0
211 */
212 }
213
Colin Crosse5729fa2014-03-21 15:04:25 -0700214 ALOGV("%s: After unplug, disconnected %zu clients",
Igor Murashkincba2c162013-03-20 15:56:31 -0700215 __FUNCTION__, clientsToDisconnect.size());
216 }
217
218 updateStatus(
219 static_cast<ICameraServiceListener::Status>(newStatus), cameraId);
220
221}
222
Mathias Agopian65ab4712010-07-14 17:59:35 -0700223int32_t CameraService::getNumberOfCameras() {
224 return mNumberOfCameras;
225}
226
227status_t CameraService::getCameraInfo(int cameraId,
228 struct CameraInfo* cameraInfo) {
Iliyan Malchev8951a972011-04-14 16:55:59 -0700229 if (!mModule) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700230 return -ENODEV;
Iliyan Malchev8951a972011-04-14 16:55:59 -0700231 }
232
Mathias Agopian65ab4712010-07-14 17:59:35 -0700233 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
234 return BAD_VALUE;
235 }
236
Iliyan Malchev8951a972011-04-14 16:55:59 -0700237 struct camera_info info;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700238 status_t rc = filterGetInfoErrorCode(
239 mModule->get_camera_info(cameraId, &info));
Iliyan Malchev8951a972011-04-14 16:55:59 -0700240 cameraInfo->facing = info.facing;
241 cameraInfo->orientation = info.orientation;
242 return rc;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700243}
244
Ruben Brunkb2119af2014-05-09 19:57:56 -0700245
246status_t CameraService::generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo) {
247 status_t ret = OK;
248 struct CameraInfo info;
249 if ((ret = getCameraInfo(cameraId, &info)) != OK) {
250 return ret;
251 }
252
253 CameraMetadata shimInfo;
254 int32_t orientation = static_cast<int32_t>(info.orientation);
255 if ((ret = shimInfo.update(ANDROID_SENSOR_ORIENTATION, &orientation, 1)) != OK) {
256 return ret;
257 }
258
259 uint8_t facing = (info.facing == CAMERA_FACING_FRONT) ?
260 ANDROID_LENS_FACING_FRONT : ANDROID_LENS_FACING_BACK;
261 if ((ret = shimInfo.update(ANDROID_LENS_FACING, &facing, 1)) != OK) {
262 return ret;
263 }
264
Igor Murashkin65d14b92014-06-17 12:03:20 -0700265 CameraParameters shimParams;
266 if ((ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)) != OK) {
267 // Error logged by callee
268 return ret;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700269 }
270
271 Vector<Size> sizes;
Ruben Brunk152dbcf2014-06-12 19:11:45 -0700272 Vector<Size> jpegSizes;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700273 Vector<int32_t> formats;
274 const char* supportedPreviewFormats;
Igor Murashkin65d14b92014-06-17 12:03:20 -0700275 {
276 shimParams.getSupportedPreviewSizes(/*out*/sizes);
277 shimParams.getSupportedPreviewFormats(/*out*/formats);
278 shimParams.getSupportedPictureSizes(/*out*/jpegSizes);
Ruben Brunkb2119af2014-05-09 19:57:56 -0700279 }
280
281 // Always include IMPLEMENTATION_DEFINED
282 formats.add(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
283
284 const size_t INTS_PER_CONFIG = 4;
285
286 // Build available stream configurations metadata
Ruben Brunk152dbcf2014-06-12 19:11:45 -0700287 size_t streamConfigSize = (sizes.size() * formats.size() + jpegSizes.size()) * INTS_PER_CONFIG;
288
289 Vector<int32_t> streamConfigs;
290 streamConfigs.setCapacity(streamConfigSize);
291
Ruben Brunkb2119af2014-05-09 19:57:56 -0700292 for (size_t i = 0; i < formats.size(); ++i) {
293 for (size_t j = 0; j < sizes.size(); ++j) {
Ruben Brunk152dbcf2014-06-12 19:11:45 -0700294 streamConfigs.add(formats[i]);
295 streamConfigs.add(sizes[j].width);
296 streamConfigs.add(sizes[j].height);
297 streamConfigs.add(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);
Ruben Brunkb2119af2014-05-09 19:57:56 -0700298 }
299 }
300
Ruben Brunk152dbcf2014-06-12 19:11:45 -0700301 for (size_t i = 0; i < jpegSizes.size(); ++i) {
302 streamConfigs.add(HAL_PIXEL_FORMAT_BLOB);
303 streamConfigs.add(jpegSizes[i].width);
304 streamConfigs.add(jpegSizes[i].height);
305 streamConfigs.add(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT);
306 }
307
Ruben Brunkb2119af2014-05-09 19:57:56 -0700308 if ((ret = shimInfo.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
Ruben Brunk152dbcf2014-06-12 19:11:45 -0700309 streamConfigs.array(), streamConfigSize)) != OK) {
Ruben Brunkb2119af2014-05-09 19:57:56 -0700310 return ret;
311 }
312
313 int64_t fakeMinFrames[0];
314 // TODO: Fixme, don't fake min frame durations.
315 if ((ret = shimInfo.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
316 fakeMinFrames, 0)) != OK) {
317 return ret;
318 }
319
320 int64_t fakeStalls[0];
321 // TODO: Fixme, don't fake stall durations.
322 if ((ret = shimInfo.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
323 fakeStalls, 0)) != OK) {
324 return ret;
325 }
326
327 *cameraInfo = shimInfo;
328 return OK;
329}
330
Zhijun He2b59be82013-09-25 10:14:30 -0700331status_t CameraService::getCameraCharacteristics(int cameraId,
332 CameraMetadata* cameraInfo) {
333 if (!cameraInfo) {
334 ALOGE("%s: cameraInfo is NULL", __FUNCTION__);
335 return BAD_VALUE;
336 }
337
338 if (!mModule) {
339 ALOGE("%s: camera hardware module doesn't exist", __FUNCTION__);
340 return -ENODEV;
341 }
342
Zhijun He2b59be82013-09-25 10:14:30 -0700343 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
344 ALOGE("%s: Invalid camera id: %d", __FUNCTION__, cameraId);
345 return BAD_VALUE;
346 }
347
348 int facing;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700349 status_t ret = OK;
350 if (mModule->common.module_api_version < CAMERA_MODULE_API_VERSION_2_0 ||
351 getDeviceVersion(cameraId, &facing) <= CAMERA_DEVICE_API_VERSION_2_1 ) {
352 /**
353 * Backwards compatibility mode for old HALs:
354 * - Convert CameraInfo into static CameraMetadata properties.
355 * - Retrieve cached CameraParameters for this camera. If none exist,
356 * attempt to open CameraClient and retrieve the CameraParameters.
357 * - Convert cached CameraParameters into static CameraMetadata
358 * properties.
359 */
360 ALOGI("%s: Switching to HAL1 shim implementation...", __FUNCTION__);
Zhijun He2b59be82013-09-25 10:14:30 -0700361
Ruben Brunkb2119af2014-05-09 19:57:56 -0700362 if ((ret = generateShimMetadata(cameraId, cameraInfo)) != OK) {
363 return ret;
364 }
Zhijun Hef05e50e2013-10-01 11:05:33 -0700365
Ruben Brunkb2119af2014-05-09 19:57:56 -0700366 } else {
367 /**
368 * Normal HAL 2.1+ codepath.
369 */
370 struct camera_info info;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700371 ret = filterGetInfoErrorCode(mModule->get_camera_info(cameraId, &info));
Ruben Brunkb2119af2014-05-09 19:57:56 -0700372 *cameraInfo = info.static_camera_characteristics;
373 }
Zhijun He2b59be82013-09-25 10:14:30 -0700374
375 return ret;
376}
377
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800378status_t CameraService::getCameraVendorTagDescriptor(/*out*/sp<VendorTagDescriptor>& desc) {
379 if (!mModule) {
380 ALOGE("%s: camera hardware module doesn't exist", __FUNCTION__);
381 return -ENODEV;
382 }
383
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800384 desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
385 return OK;
386}
387
Igor Murashkin634a5152013-02-20 17:15:11 -0800388int CameraService::getDeviceVersion(int cameraId, int* facing) {
389 struct camera_info info;
390 if (mModule->get_camera_info(cameraId, &info) != OK) {
391 return -1;
392 }
393
394 int deviceVersion;
395 if (mModule->common.module_api_version >= CAMERA_MODULE_API_VERSION_2_0) {
396 deviceVersion = info.device_version;
397 } else {
398 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
399 }
400
401 if (facing) {
402 *facing = info.facing;
403 }
404
405 return deviceVersion;
406}
407
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700408status_t CameraService::filterOpenErrorCode(status_t err) {
409 switch(err) {
410 case NO_ERROR:
411 case -EBUSY:
412 case -EINVAL:
413 case -EUSERS:
414 return err;
415 default:
416 break;
Igor Murashkinbfc99152013-02-27 12:55:20 -0800417 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700418 return -ENODEV;
419}
Igor Murashkinbfc99152013-02-27 12:55:20 -0800420
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700421status_t CameraService::filterGetInfoErrorCode(status_t err) {
422 switch(err) {
423 case NO_ERROR:
424 case -EINVAL:
425 return err;
426 default:
427 break;
428 }
429 return -ENODEV;
Igor Murashkinbfc99152013-02-27 12:55:20 -0800430}
431
Ruben Brunkd1176ef2014-02-21 10:51:38 -0800432bool CameraService::setUpVendorTags() {
433 vendor_tag_ops_t vOps = vendor_tag_ops_t();
434
435 // Check if vendor operations have been implemented
436 if (mModule->get_vendor_tag_ops == NULL) {
437 ALOGI("%s: No vendor tags defined for this device.", __FUNCTION__);
438 return false;
439 }
440
441 ATRACE_BEGIN("camera3->get_metadata_vendor_tag_ops");
442 mModule->get_vendor_tag_ops(&vOps);
443 ATRACE_END();
444
445 // Ensure all vendor operations are present
446 if (vOps.get_tag_count == NULL || vOps.get_all_tags == NULL ||
447 vOps.get_section_name == NULL || vOps.get_tag_name == NULL ||
448 vOps.get_tag_type == NULL) {
449 ALOGE("%s: Vendor tag operations not fully defined. Ignoring definitions."
450 , __FUNCTION__);
451 return false;
452 }
453
454 // Read all vendor tag definitions into a descriptor
455 sp<VendorTagDescriptor> desc;
456 status_t res;
457 if ((res = VendorTagDescriptor::createDescriptorFromOps(&vOps, /*out*/desc))
458 != OK) {
459 ALOGE("%s: Could not generate descriptor from vendor tag operations,"
460 "received error %s (%d). Camera clients will not be able to use"
461 "vendor tags", __FUNCTION__, strerror(res), res);
462 return false;
463 }
464
465 // Set the global descriptor to use with camera metadata
466 VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
467 return true;
468}
469
Ruben Brunkb2119af2014-05-09 19:57:56 -0700470status_t CameraService::initializeShimMetadata(int cameraId) {
471 int pid = getCallingPid();
472 int uid = getCallingUid();
473 status_t ret = validateConnect(cameraId, uid);
474 if (ret != OK) {
Igor Murashkin65d14b92014-06-17 12:03:20 -0700475 // Error already logged by callee
Ruben Brunkb2119af2014-05-09 19:57:56 -0700476 return ret;
477 }
478
479 bool needsNewClient = false;
480 sp<Client> client;
481
482 String16 internalPackageName("media");
483 { // Scope for service lock
484 Mutex::Autolock lock(mServiceLock);
485 if (mClient[cameraId] != NULL) {
486 client = static_cast<Client*>(mClient[cameraId].promote().get());
487 }
488 if (client == NULL) {
489 needsNewClient = true;
Igor Murashkina858ea02014-08-19 14:53:08 -0700490 ret = connectHelperLocked(/*out*/client,
491 /*cameraClient*/NULL, // Empty binder callbacks
Ruben Brunkb2119af2014-05-09 19:57:56 -0700492 cameraId,
493 internalPackageName,
494 uid,
Igor Murashkina858ea02014-08-19 14:53:08 -0700495 pid);
Ruben Brunkb2119af2014-05-09 19:57:56 -0700496
497 if (ret != OK) {
Igor Murashkin65d14b92014-06-17 12:03:20 -0700498 // Error already logged by callee
Ruben Brunkb2119af2014-05-09 19:57:56 -0700499 return ret;
500 }
501 }
502
503 if (client == NULL) {
504 ALOGE("%s: Could not connect to client camera device.", __FUNCTION__);
505 return BAD_VALUE;
506 }
507
508 String8 rawParams = client->getParameters();
509 CameraParameters params(rawParams);
510 mShimParams.add(cameraId, params);
511 }
512
513 // Close client if one was opened solely for this call
514 if (needsNewClient) {
515 client->disconnect();
516 }
517 return OK;
518}
519
Igor Murashkin65d14b92014-06-17 12:03:20 -0700520status_t CameraService::getLegacyParametersLazy(int cameraId,
521 /*out*/
522 CameraParameters* parameters) {
523
524 ALOGV("%s: for cameraId: %d", __FUNCTION__, cameraId);
525
526 status_t ret = 0;
527
528 if (parameters == NULL) {
529 ALOGE("%s: parameters must not be null", __FUNCTION__);
530 return BAD_VALUE;
531 }
532
533 ssize_t index = -1;
534 { // Scope for service lock
535 Mutex::Autolock lock(mServiceLock);
536 index = mShimParams.indexOfKey(cameraId);
537 // Release service lock so initializeShimMetadata can be called correctly.
538
539 if (index >= 0) {
540 *parameters = mShimParams[index];
541 }
542 }
543
544 if (index < 0) {
545 int64_t token = IPCThreadState::self()->clearCallingIdentity();
546 ret = initializeShimMetadata(cameraId);
547 IPCThreadState::self()->restoreCallingIdentity(token);
548 if (ret != OK) {
549 // Error already logged by callee
550 return ret;
551 }
552
553 { // Scope for service lock
554 Mutex::Autolock lock(mServiceLock);
555 index = mShimParams.indexOfKey(cameraId);
556
557 LOG_ALWAYS_FATAL_IF(index < 0, "index should have been initialized");
558
559 *parameters = mShimParams[index];
560 }
561 }
562
563 return OK;
564}
565
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700566status_t CameraService::validateConnect(int cameraId,
Igor Murashkine6800ce2013-03-04 17:25:57 -0800567 /*inout*/
568 int& clientUid) const {
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800569
Mathias Agopian65ab4712010-07-14 17:59:35 -0700570 int callingPid = getCallingPid();
Tyler Luu5861a9a2011-10-06 00:00:03 -0500571
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800572 if (clientUid == USE_CALLING_UID) {
573 clientUid = getCallingUid();
574 } else {
575 // We only trust our own process to forward client UIDs
576 if (callingPid != getpid()) {
577 ALOGE("CameraService::connect X (pid %d) rejected (don't trust clientUid)",
578 callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700579 return PERMISSION_DENIED;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800580 }
581 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700582
Iliyan Malchev8951a972011-04-14 16:55:59 -0700583 if (!mModule) {
Steve Block29357bc2012-01-06 19:20:56 +0000584 ALOGE("Camera HAL module not loaded");
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700585 return -ENODEV;
Iliyan Malchev8951a972011-04-14 16:55:59 -0700586 }
587
Mathias Agopian65ab4712010-07-14 17:59:35 -0700588 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
Steve Block29357bc2012-01-06 19:20:56 +0000589 ALOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700590 callingPid, cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700591 return -ENODEV;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700592 }
593
Wu-cheng Lia3355432011-05-20 14:54:25 +0800594 char value[PROPERTY_VALUE_MAX];
595 property_get("sys.secpolicy.camera.disabled", value, "0");
596 if (strcmp(value, "1") == 0) {
597 // Camera is disabled by DevicePolicyManager.
Steve Blockdf64d152012-01-04 20:05:49 +0000598 ALOGI("Camera is disabled. connect X (pid %d) rejected", callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700599 return -EACCES;
Wu-cheng Lia3355432011-05-20 14:54:25 +0800600 }
601
Igor Murashkincba2c162013-03-20 15:56:31 -0700602 ICameraServiceListener::Status currentStatus = getStatus(cameraId);
603 if (currentStatus == ICameraServiceListener::STATUS_NOT_PRESENT) {
604 ALOGI("Camera is not plugged in,"
605 " connect X (pid %d) rejected", callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700606 return -ENODEV;
Igor Murashkincba2c162013-03-20 15:56:31 -0700607 } else if (currentStatus == ICameraServiceListener::STATUS_ENUMERATING) {
608 ALOGI("Camera is enumerating,"
609 " connect X (pid %d) rejected", callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700610 return -EBUSY;
Igor Murashkincba2c162013-03-20 15:56:31 -0700611 }
612 // Else don't check for STATUS_NOT_AVAILABLE.
613 // -- It's done implicitly in canConnectUnsafe /w the mBusy array
614
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700615 return OK;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800616}
617
618bool CameraService::canConnectUnsafe(int cameraId,
619 const String16& clientPackageName,
620 const sp<IBinder>& remoteCallback,
Igor Murashkine7ee7632013-06-11 18:10:18 -0700621 sp<BasicClient> &client) {
Igor Murashkine6800ce2013-03-04 17:25:57 -0800622 String8 clientName8(clientPackageName);
623 int callingPid = getCallingPid();
624
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800625 if (mClient[cameraId] != 0) {
626 client = mClient[cameraId].promote();
627 if (client != 0) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700628 if (remoteCallback == client->getRemote()) {
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800629 LOG1("CameraService::connect X (pid %d) (the same client)",
630 callingPid);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800631 return true;
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800632 } else {
Igor Murashkine6800ce2013-03-04 17:25:57 -0800633 // TODOSC: need to support 1 regular client,
634 // multiple shared clients here
635 ALOGW("CameraService::connect X (pid %d) rejected"
636 " (existing client).", callingPid);
637 return false;
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800638 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800639 }
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800640 mClient[cameraId].clear();
641 }
642
Igor Murashkin634a5152013-02-20 17:15:11 -0800643 /*
644 mBusy is set to false as the last step of the Client destructor,
645 after which it is guaranteed that the Client destructor has finished (
646 including any inherited destructors)
647
648 We only need this for a Client subclasses since we don't allow
649 multiple Clents to be opened concurrently, but multiple BasicClient
650 would be fine
651 */
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800652 if (mBusy[cameraId]) {
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800653 ALOGW("CameraService::connect X (pid %d, \"%s\") rejected"
654 " (camera %d is still busy).", callingPid,
655 clientName8.string(), cameraId);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800656 return false;
657 }
658
659 return true;
660}
661
Igor Murashkina858ea02014-08-19 14:53:08 -0700662status_t CameraService::connectHelperLocked(
663 /*out*/
664 sp<Client>& client,
665 /*in*/
666 const sp<ICameraClient>& cameraClient,
667 int cameraId,
668 const String16& clientPackageName,
669 int clientUid,
670 int callingPid,
671 int halVersion,
672 bool legacyMode) {
Ruben Brunkb2119af2014-05-09 19:57:56 -0700673
674 int facing = -1;
675 int deviceVersion = getDeviceVersion(cameraId, &facing);
676
Zhijun Heb10cdad2014-06-16 16:38:35 -0700677 if (halVersion < 0 || halVersion == deviceVersion) {
678 // Default path: HAL version is unspecified by caller, create CameraClient
679 // based on device version reported by the HAL.
680 switch(deviceVersion) {
681 case CAMERA_DEVICE_API_VERSION_1_0:
682 client = new CameraClient(this, cameraClient,
683 clientPackageName, cameraId,
Igor Murashkina858ea02014-08-19 14:53:08 -0700684 facing, callingPid, clientUid, getpid(), legacyMode);
Zhijun Heb10cdad2014-06-16 16:38:35 -0700685 break;
686 case CAMERA_DEVICE_API_VERSION_2_0:
687 case CAMERA_DEVICE_API_VERSION_2_1:
688 case CAMERA_DEVICE_API_VERSION_3_0:
689 case CAMERA_DEVICE_API_VERSION_3_1:
690 case CAMERA_DEVICE_API_VERSION_3_2:
691 client = new Camera2Client(this, cameraClient,
692 clientPackageName, cameraId,
Igor Murashkina858ea02014-08-19 14:53:08 -0700693 facing, callingPid, clientUid, getpid(), legacyMode);
Zhijun Heb10cdad2014-06-16 16:38:35 -0700694 break;
695 case -1:
696 ALOGE("Invalid camera id %d", cameraId);
697 return BAD_VALUE;
698 default:
699 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
700 return INVALID_OPERATION;
701 }
702 } else {
703 // A particular HAL version is requested by caller. Create CameraClient
704 // based on the requested HAL version.
705 if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
706 halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
707 // Only support higher HAL version device opened as HAL1.0 device.
708 client = new CameraClient(this, cameraClient,
709 clientPackageName, cameraId,
Igor Murashkina858ea02014-08-19 14:53:08 -0700710 facing, callingPid, clientUid, getpid(), legacyMode);
Zhijun Heb10cdad2014-06-16 16:38:35 -0700711 } else {
712 // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
713 ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
714 " opened as HAL %x device", halVersion, deviceVersion,
715 CAMERA_DEVICE_API_VERSION_1_0);
716 return INVALID_OPERATION;
717 }
Ruben Brunkb2119af2014-05-09 19:57:56 -0700718 }
719
720 status_t status = connectFinishUnsafe(client, client->getRemote());
721 if (status != OK) {
722 // this is probably not recoverable.. maybe the client can try again
Ruben Brunkb2119af2014-05-09 19:57:56 -0700723 return status;
724 }
725
726 mClient[cameraId] = client;
727 LOG1("CameraService::connect X (id %d, this pid is %d)", cameraId,
728 getpid());
729
730 return OK;
731}
732
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700733status_t CameraService::connect(
Igor Murashkine6800ce2013-03-04 17:25:57 -0800734 const sp<ICameraClient>& cameraClient,
735 int cameraId,
736 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700737 int clientUid,
738 /*out*/
739 sp<ICamera>& device) {
Igor Murashkine6800ce2013-03-04 17:25:57 -0800740
741 String8 clientName8(clientPackageName);
742 int callingPid = getCallingPid();
743
744 LOG1("CameraService::connect E (pid %d \"%s\", id %d)", callingPid,
745 clientName8.string(), cameraId);
746
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700747 status_t status = validateConnect(cameraId, /*inout*/clientUid);
748 if (status != OK) {
749 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700750 }
751
Igor Murashkine6800ce2013-03-04 17:25:57 -0800752
Igor Murashkine7ee7632013-06-11 18:10:18 -0700753 sp<Client> client;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700754 {
755 Mutex::Autolock lock(mServiceLock);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700756 sp<BasicClient> clientTmp;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700757 if (!canConnectUnsafe(cameraId, clientPackageName,
758 cameraClient->asBinder(),
Igor Murashkine7ee7632013-06-11 18:10:18 -0700759 /*out*/clientTmp)) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700760 return -EBUSY;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700761 } else if (client.get() != NULL) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700762 device = static_cast<Client*>(clientTmp.get());
763 return OK;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700764 }
765
Igor Murashkina858ea02014-08-19 14:53:08 -0700766 status = connectHelperLocked(/*out*/client,
767 cameraClient,
Ruben Brunkb2119af2014-05-09 19:57:56 -0700768 cameraId,
769 clientPackageName,
770 clientUid,
Igor Murashkina858ea02014-08-19 14:53:08 -0700771 callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700772 if (status != OK) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700773 return status;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700774 }
775
Igor Murashkine6800ce2013-03-04 17:25:57 -0800776 }
Igor Murashkinacd695c2013-03-13 17:23:00 -0700777 // important: release the mutex here so the client can call back
778 // into the service from its destructor (can be at the end of the call)
Igor Murashkinbfc99152013-02-27 12:55:20 -0800779
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700780 device = client;
781 return OK;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700782}
783
Zhijun Heb10cdad2014-06-16 16:38:35 -0700784status_t CameraService::connectLegacy(
785 const sp<ICameraClient>& cameraClient,
786 int cameraId, int halVersion,
787 const String16& clientPackageName,
788 int clientUid,
789 /*out*/
790 sp<ICamera>& device) {
791
Igor Murashkin3d07d1a2014-06-20 11:27:03 -0700792 if (halVersion != CAMERA_HAL_API_VERSION_UNSPECIFIED &&
793 mModule->common.module_api_version < CAMERA_MODULE_API_VERSION_2_3) {
794 /*
795 * Either the HAL version is unspecified in which case this just creates
796 * a camera client selected by the latest device version, or
797 * it's a particular version in which case the HAL must supported
798 * the open_legacy call
799 */
Zhijun Heb10cdad2014-06-16 16:38:35 -0700800 ALOGE("%s: camera HAL module version %x doesn't support connecting to legacy HAL devices!",
801 __FUNCTION__, mModule->common.module_api_version);
802 return INVALID_OPERATION;
803 }
804
805 String8 clientName8(clientPackageName);
806 int callingPid = getCallingPid();
807
808 LOG1("CameraService::connect legacy E (pid %d \"%s\", id %d)", callingPid,
809 clientName8.string(), cameraId);
810
811 status_t status = validateConnect(cameraId, /*inout*/clientUid);
812 if (status != OK) {
813 return status;
814 }
815
816 sp<Client> client;
817 {
818 Mutex::Autolock lock(mServiceLock);
819 sp<BasicClient> clientTmp;
820 if (!canConnectUnsafe(cameraId, clientPackageName,
821 cameraClient->asBinder(),
822 /*out*/clientTmp)) {
823 return -EBUSY;
824 } else if (client.get() != NULL) {
825 device = static_cast<Client*>(clientTmp.get());
826 return OK;
827 }
828
Igor Murashkina858ea02014-08-19 14:53:08 -0700829 status = connectHelperLocked(/*out*/client,
830 cameraClient,
Zhijun Heb10cdad2014-06-16 16:38:35 -0700831 cameraId,
832 clientPackageName,
833 clientUid,
834 callingPid,
Igor Murashkina858ea02014-08-19 14:53:08 -0700835 halVersion,
836 /*legacyMode*/true);
Zhijun Heb10cdad2014-06-16 16:38:35 -0700837 if (status != OK) {
838 return status;
839 }
840
841 }
842 // important: release the mutex here so the client can call back
843 // into the service from its destructor (can be at the end of the call)
844
845 device = client;
846 return OK;
847}
848
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700849status_t CameraService::connectFinishUnsafe(const sp<BasicClient>& client,
850 const sp<IBinder>& remoteCallback) {
851 status_t status = client->initialize(mModule);
852 if (status != OK) {
853 return status;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800854 }
Ruben Brunkb2119af2014-05-09 19:57:56 -0700855 if (remoteCallback != NULL) {
856 remoteCallback->linkToDeath(this);
857 }
Igor Murashkine6800ce2013-03-04 17:25:57 -0800858
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700859 return OK;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800860}
861
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700862status_t CameraService::connectPro(
Igor Murashkin634a5152013-02-20 17:15:11 -0800863 const sp<IProCameraCallbacks>& cameraCb,
Igor Murashkinc073ba52013-02-26 14:32:34 -0800864 int cameraId,
865 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700866 int clientUid,
867 /*out*/
868 sp<IProCameraUser>& device)
Igor Murashkin634a5152013-02-20 17:15:11 -0800869{
Natalie Silvanoviche1b55da2014-05-01 14:44:52 -0700870 if (cameraCb == 0) {
871 ALOGE("%s: Callback must not be null", __FUNCTION__);
872 return BAD_VALUE;
873 }
874
Igor Murashkinbfc99152013-02-27 12:55:20 -0800875 String8 clientName8(clientPackageName);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700876 int callingPid = getCallingPid();
Igor Murashkin634a5152013-02-20 17:15:11 -0800877
Igor Murashkine6800ce2013-03-04 17:25:57 -0800878 LOG1("CameraService::connectPro E (pid %d \"%s\", id %d)", callingPid,
879 clientName8.string(), cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700880 status_t status = validateConnect(cameraId, /*inout*/clientUid);
881 if (status != OK) {
882 return status;
Igor Murashkin634a5152013-02-20 17:15:11 -0800883 }
884
Igor Murashkinacd695c2013-03-13 17:23:00 -0700885 sp<ProClient> client;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800886 {
Igor Murashkinacd695c2013-03-13 17:23:00 -0700887 Mutex::Autolock lock(mServiceLock);
888 {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700889 sp<BasicClient> client;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700890 if (!canConnectUnsafe(cameraId, clientPackageName,
891 cameraCb->asBinder(),
892 /*out*/client)) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700893 return -EBUSY;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700894 }
895 }
896
897 int facing = -1;
898 int deviceVersion = getDeviceVersion(cameraId, &facing);
899
900 switch(deviceVersion) {
901 case CAMERA_DEVICE_API_VERSION_1_0:
902 ALOGE("Camera id %d uses HALv1, doesn't support ProCamera",
903 cameraId);
Ruben Brunk17963d12013-08-19 15:21:19 -0700904 return -EOPNOTSUPP;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700905 break;
906 case CAMERA_DEVICE_API_VERSION_2_0:
907 case CAMERA_DEVICE_API_VERSION_2_1:
Zhijun He47110052013-07-22 17:34:34 -0700908 case CAMERA_DEVICE_API_VERSION_3_0:
Zhijun He95dd5ba2014-03-26 18:18:00 -0700909 case CAMERA_DEVICE_API_VERSION_3_1:
910 case CAMERA_DEVICE_API_VERSION_3_2:
Eino-Ville Talvala63d877f2014-06-16 19:21:12 -0700911 client = new ProCamera2Client(this, cameraCb, clientPackageName,
912 cameraId, facing, callingPid, clientUid, getpid());
Igor Murashkinacd695c2013-03-13 17:23:00 -0700913 break;
914 case -1:
915 ALOGE("Invalid camera id %d", cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700916 return BAD_VALUE;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700917 default:
918 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700919 return INVALID_OPERATION;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800920 }
Igor Murashkinacd695c2013-03-13 17:23:00 -0700921
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700922 status_t status = connectFinishUnsafe(client, client->getRemote());
923 if (status != OK) {
924 return status;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700925 }
926
927 mProClientList[cameraId].push(client);
928
929 LOG1("CameraService::connectPro X (id %d, this pid is %d)", cameraId,
930 getpid());
Igor Murashkine6800ce2013-03-04 17:25:57 -0800931 }
Igor Murashkinacd695c2013-03-13 17:23:00 -0700932 // important: release the mutex here so the client can call back
933 // into the service from its destructor (can be at the end of the call)
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700934 device = client;
935 return OK;
Igor Murashkinbfc99152013-02-27 12:55:20 -0800936}
Igor Murashkin634a5152013-02-20 17:15:11 -0800937
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700938status_t CameraService::connectDevice(
Igor Murashkine7ee7632013-06-11 18:10:18 -0700939 const sp<ICameraDeviceCallbacks>& cameraCb,
940 int cameraId,
941 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700942 int clientUid,
943 /*out*/
944 sp<ICameraDeviceUser>& device)
Igor Murashkine7ee7632013-06-11 18:10:18 -0700945{
Igor Murashkine7ee7632013-06-11 18:10:18 -0700946
947 String8 clientName8(clientPackageName);
948 int callingPid = getCallingPid();
949
950 LOG1("CameraService::connectDevice E (pid %d \"%s\", id %d)", callingPid,
951 clientName8.string(), cameraId);
952
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700953 status_t status = validateConnect(cameraId, /*inout*/clientUid);
954 if (status != OK) {
955 return status;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700956 }
957
958 sp<CameraDeviceClient> client;
959 {
960 Mutex::Autolock lock(mServiceLock);
961 {
962 sp<BasicClient> client;
963 if (!canConnectUnsafe(cameraId, clientPackageName,
964 cameraCb->asBinder(),
965 /*out*/client)) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700966 return -EBUSY;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700967 }
968 }
969
970 int facing = -1;
971 int deviceVersion = getDeviceVersion(cameraId, &facing);
972
Igor Murashkine7ee7632013-06-11 18:10:18 -0700973 switch(deviceVersion) {
974 case CAMERA_DEVICE_API_VERSION_1_0:
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700975 ALOGW("Camera using old HAL version: %d", deviceVersion);
Ruben Brunk17963d12013-08-19 15:21:19 -0700976 return -EOPNOTSUPP;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700977 // TODO: don't allow 2.0 Only allow 2.1 and higher
978 case CAMERA_DEVICE_API_VERSION_2_0:
979 case CAMERA_DEVICE_API_VERSION_2_1:
980 case CAMERA_DEVICE_API_VERSION_3_0:
Zhijun He95dd5ba2014-03-26 18:18:00 -0700981 case CAMERA_DEVICE_API_VERSION_3_1:
982 case CAMERA_DEVICE_API_VERSION_3_2:
Eino-Ville Talvala63d877f2014-06-16 19:21:12 -0700983 client = new CameraDeviceClient(this, cameraCb, clientPackageName,
984 cameraId, facing, callingPid, clientUid, getpid());
Igor Murashkine7ee7632013-06-11 18:10:18 -0700985 break;
986 case -1:
987 ALOGE("Invalid camera id %d", cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700988 return BAD_VALUE;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700989 default:
990 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700991 return INVALID_OPERATION;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700992 }
993
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700994 status_t status = connectFinishUnsafe(client, client->getRemote());
995 if (status != OK) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700996 // this is probably not recoverable.. maybe the client can try again
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700997 return status;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700998 }
999
1000 LOG1("CameraService::connectDevice X (id %d, this pid is %d)", cameraId,
1001 getpid());
1002
1003 mClient[cameraId] = client;
1004 }
1005 // important: release the mutex here so the client can call back
1006 // into the service from its destructor (can be at the end of the call)
1007
Ruben Brunk0f61d8f2013-08-08 13:07:18 -07001008 device = client;
1009 return OK;
Igor Murashkine7ee7632013-06-11 18:10:18 -07001010}
1011
1012
Igor Murashkinbfc99152013-02-27 12:55:20 -08001013status_t CameraService::addListener(
1014 const sp<ICameraServiceListener>& listener) {
1015 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
Igor Murashkin634a5152013-02-20 17:15:11 -08001016
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001017 if (listener == 0) {
1018 ALOGE("%s: Listener must not be null", __FUNCTION__);
1019 return BAD_VALUE;
1020 }
1021
Igor Murashkinbfc99152013-02-27 12:55:20 -08001022 Mutex::Autolock lock(mServiceLock);
1023
1024 Vector<sp<ICameraServiceListener> >::iterator it, end;
1025 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) {
1026 if ((*it)->asBinder() == listener->asBinder()) {
1027 ALOGW("%s: Tried to add listener %p which was already subscribed",
1028 __FUNCTION__, listener.get());
1029 return ALREADY_EXISTS;
1030 }
1031 }
1032
1033 mListenerList.push_back(listener);
1034
Igor Murashkincba2c162013-03-20 15:56:31 -07001035 /* Immediately signal current status to this listener only */
1036 {
1037 Mutex::Autolock m(mStatusMutex) ;
1038 int numCams = getNumberOfCameras();
1039 for (int i = 0; i < numCams; ++i) {
1040 listener->onStatusChanged(mStatusList[i], i);
1041 }
1042 }
1043
Igor Murashkinbfc99152013-02-27 12:55:20 -08001044 return OK;
1045}
1046status_t CameraService::removeListener(
1047 const sp<ICameraServiceListener>& listener) {
1048 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
1049
Igor Murashkinbd3e2e02014-03-17 13:01:41 -07001050 if (listener == 0) {
1051 ALOGE("%s: Listener must not be null", __FUNCTION__);
1052 return BAD_VALUE;
1053 }
1054
Igor Murashkinbfc99152013-02-27 12:55:20 -08001055 Mutex::Autolock lock(mServiceLock);
1056
1057 Vector<sp<ICameraServiceListener> >::iterator it;
1058 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) {
1059 if ((*it)->asBinder() == listener->asBinder()) {
1060 mListenerList.erase(it);
1061 return OK;
1062 }
1063 }
1064
1065 ALOGW("%s: Tried to remove a listener %p which was not subscribed",
1066 __FUNCTION__, listener.get());
1067
1068 return BAD_VALUE;
Igor Murashkin634a5152013-02-20 17:15:11 -08001069}
1070
Igor Murashkin65d14b92014-06-17 12:03:20 -07001071status_t CameraService::getLegacyParameters(
1072 int cameraId,
1073 /*out*/
1074 String16* parameters) {
1075 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1076
1077 if (parameters == NULL) {
1078 ALOGE("%s: parameters must not be null", __FUNCTION__);
1079 return BAD_VALUE;
1080 }
1081
1082 status_t ret = 0;
1083
1084 CameraParameters shimParams;
1085 if ((ret = getLegacyParametersLazy(cameraId, /*out*/&shimParams)) != OK) {
1086 // Error logged by caller
1087 return ret;
1088 }
1089
1090 String8 shimParamsString8 = shimParams.flatten();
1091 String16 shimParamsString16 = String16(shimParamsString8);
1092
1093 *parameters = shimParamsString16;
1094
1095 return OK;
1096}
1097
1098status_t CameraService::supportsCameraApi(int cameraId, int apiVersion) {
1099 ALOGV("%s: for camera ID = %d", __FUNCTION__, cameraId);
1100
1101 switch (apiVersion) {
1102 case API_VERSION_1:
1103 case API_VERSION_2:
1104 break;
1105 default:
1106 ALOGE("%s: Bad API version %d", __FUNCTION__, apiVersion);
1107 return BAD_VALUE;
1108 }
1109
1110 int facing = -1;
1111 int deviceVersion = getDeviceVersion(cameraId, &facing);
1112
1113 switch(deviceVersion) {
1114 case CAMERA_DEVICE_API_VERSION_1_0:
1115 case CAMERA_DEVICE_API_VERSION_2_0:
1116 case CAMERA_DEVICE_API_VERSION_2_1:
1117 case CAMERA_DEVICE_API_VERSION_3_0:
1118 case CAMERA_DEVICE_API_VERSION_3_1:
1119 if (apiVersion == API_VERSION_2) {
1120 ALOGV("%s: Camera id %d uses HAL prior to HAL3.2, doesn't support api2 without shim",
1121 __FUNCTION__, cameraId);
1122 return -EOPNOTSUPP;
1123 } else { // if (apiVersion == API_VERSION_1) {
1124 ALOGV("%s: Camera id %d uses older HAL before 3.2, but api1 is always supported",
1125 __FUNCTION__, cameraId);
1126 return OK;
1127 }
1128 case CAMERA_DEVICE_API_VERSION_3_2:
1129 ALOGV("%s: Camera id %d uses HAL3.2 or newer, supports api1/api2 directly",
1130 __FUNCTION__, cameraId);
1131 return OK;
1132 case -1:
1133 ALOGE("%s: Invalid camera id %d", __FUNCTION__, cameraId);
1134 return BAD_VALUE;
1135 default:
1136 ALOGE("%s: Unknown camera device HAL version: %d", __FUNCTION__, deviceVersion);
1137 return INVALID_OPERATION;
1138 }
1139
1140 return OK;
1141}
1142
Igor Murashkin634a5152013-02-20 17:15:11 -08001143void CameraService::removeClientByRemote(const wp<IBinder>& remoteBinder) {
1144 int callingPid = getCallingPid();
1145 LOG1("CameraService::removeClientByRemote E (pid %d)", callingPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001146
Igor Murashkinecf17e82012-10-02 16:05:11 -07001147 // Declare this before the lock to make absolutely sure the
1148 // destructor won't be called with the lock held.
1149 Mutex::Autolock lock(mServiceLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001150
Igor Murashkinecf17e82012-10-02 16:05:11 -07001151 int outIndex;
Igor Murashkine7ee7632013-06-11 18:10:18 -07001152 sp<BasicClient> client = findClientUnsafe(remoteBinder, outIndex);
Igor Murashkinecf17e82012-10-02 16:05:11 -07001153
1154 if (client != 0) {
1155 // Found our camera, clear and leave.
1156 LOG1("removeClient: clear camera %d", outIndex);
Igor Murashkinecf17e82012-10-02 16:05:11 -07001157
Ruben Brunkb2119af2014-05-09 19:57:56 -07001158 sp<IBinder> remote = client->getRemote();
1159 if (remote != NULL) {
1160 remote->unlinkToDeath(this);
1161 }
1162
1163 mClient[outIndex].clear();
Igor Murashkin634a5152013-02-20 17:15:11 -08001164 } else {
1165
1166 sp<ProClient> clientPro = findProClientUnsafe(remoteBinder);
1167
1168 if (clientPro != NULL) {
1169 // Found our camera, clear and leave.
1170 LOG1("removeClient: clear pro %p", clientPro.get());
1171
1172 clientPro->getRemoteCallback()->asBinder()->unlinkToDeath(this);
1173 }
Igor Murashkinecf17e82012-10-02 16:05:11 -07001174 }
1175
Igor Murashkin634a5152013-02-20 17:15:11 -08001176 LOG1("CameraService::removeClientByRemote X (pid %d)", callingPid);
1177}
1178
1179sp<CameraService::ProClient> CameraService::findProClientUnsafe(
1180 const wp<IBinder>& cameraCallbacksRemote)
1181{
1182 sp<ProClient> clientPro;
1183
1184 for (int i = 0; i < mNumberOfCameras; ++i) {
1185 Vector<size_t> removeIdx;
1186
1187 for (size_t j = 0; j < mProClientList[i].size(); ++j) {
1188 wp<ProClient> cl = mProClientList[i][j];
1189
1190 sp<ProClient> clStrong = cl.promote();
1191 if (clStrong != NULL && clStrong->getRemote() == cameraCallbacksRemote) {
1192 clientPro = clStrong;
1193 break;
1194 } else if (clStrong == NULL) {
1195 // mark to clean up dead ptr
1196 removeIdx.push(j);
1197 }
1198 }
1199
1200 // remove stale ptrs (in reverse so the indices dont change)
1201 for (ssize_t j = (ssize_t)removeIdx.size() - 1; j >= 0; --j) {
1202 mProClientList[i].removeAt(removeIdx[j]);
1203 }
1204
1205 }
1206
1207 return clientPro;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001208}
1209
Igor Murashkine7ee7632013-06-11 18:10:18 -07001210sp<CameraService::BasicClient> CameraService::findClientUnsafe(
Igor Murashkin294d0ec2012-10-05 10:44:57 -07001211 const wp<IBinder>& cameraClient, int& outIndex) {
Igor Murashkine7ee7632013-06-11 18:10:18 -07001212 sp<BasicClient> client;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001213
1214 for (int i = 0; i < mNumberOfCameras; i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001215
1216 // This happens when we have already disconnected (or this is
1217 // just another unused camera).
1218 if (mClient[i] == 0) continue;
1219
1220 // Promote mClient. It can fail if we are called from this path:
Igor Murashkin634a5152013-02-20 17:15:11 -08001221 // Client::~Client() -> disconnect() -> removeClientByRemote().
Mathias Agopian65ab4712010-07-14 17:59:35 -07001222 client = mClient[i].promote();
1223
Igor Murashkinecf17e82012-10-02 16:05:11 -07001224 // Clean up stale client entry
1225 if (client == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001226 mClient[i].clear();
1227 continue;
1228 }
1229
Igor Murashkine7ee7632013-06-11 18:10:18 -07001230 if (cameraClient == client->getRemote()) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001231 // Found our camera
1232 outIndex = i;
1233 return client;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001234 }
1235 }
1236
Igor Murashkinecf17e82012-10-02 16:05:11 -07001237 outIndex = -1;
1238 return NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001239}
1240
Igor Murashkine7ee7632013-06-11 18:10:18 -07001241CameraService::BasicClient* CameraService::getClientByIdUnsafe(int cameraId) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001242 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
Keun young Parkd8973a72012-03-28 14:13:09 -07001243 return mClient[cameraId].unsafe_get();
1244}
1245
1246Mutex* CameraService::getClientLockById(int cameraId) {
1247 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
1248 return &mClientLock[cameraId];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001249}
1250
Igor Murashkin634a5152013-02-20 17:15:11 -08001251sp<CameraService::BasicClient> CameraService::getClientByRemote(
Igor Murashkin294d0ec2012-10-05 10:44:57 -07001252 const wp<IBinder>& cameraClient) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001253
1254 // Declare this before the lock to make absolutely sure the
1255 // destructor won't be called with the lock held.
Igor Murashkin634a5152013-02-20 17:15:11 -08001256 sp<BasicClient> client;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001257
1258 Mutex::Autolock lock(mServiceLock);
1259
1260 int outIndex;
1261 client = findClientUnsafe(cameraClient, outIndex);
1262
1263 return client;
1264}
1265
Mathias Agopian65ab4712010-07-14 17:59:35 -07001266status_t CameraService::onTransact(
1267 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
1268 // Permission checks
1269 switch (code) {
1270 case BnCameraService::CONNECT:
Igor Murashkin634a5152013-02-20 17:15:11 -08001271 case BnCameraService::CONNECT_PRO:
Eino-Ville Talvala63d877f2014-06-16 19:21:12 -07001272 case BnCameraService::CONNECT_DEVICE:
Zhijun Heb10cdad2014-06-16 16:38:35 -07001273 case BnCameraService::CONNECT_LEGACY:
Mathias Agopian65ab4712010-07-14 17:59:35 -07001274 const int pid = getCallingPid();
1275 const int self_pid = getpid();
1276 if (pid != self_pid) {
1277 // we're called from a different process, do the real check
1278 if (!checkCallingPermission(
1279 String16("android.permission.CAMERA"))) {
1280 const int uid = getCallingUid();
Steve Block29357bc2012-01-06 19:20:56 +00001281 ALOGE("Permission Denial: "
Mathias Agopian65ab4712010-07-14 17:59:35 -07001282 "can't use the camera pid=%d, uid=%d", pid, uid);
1283 return PERMISSION_DENIED;
1284 }
1285 }
1286 break;
1287 }
1288
1289 return BnCameraService::onTransact(code, data, reply, flags);
1290}
1291
1292// The reason we need this busy bit is a new CameraService::connect() request
1293// may come in while the previous Client's destructor has not been run or is
1294// still running. If the last strong reference of the previous Client is gone
1295// but the destructor has not been finished, we should not allow the new Client
1296// to be created because we need to wait for the previous Client to tear down
1297// the hardware first.
1298void CameraService::setCameraBusy(int cameraId) {
1299 android_atomic_write(1, &mBusy[cameraId]);
Igor Murashkinecf17e82012-10-02 16:05:11 -07001300
1301 ALOGV("setCameraBusy cameraId=%d", cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001302}
1303
1304void CameraService::setCameraFree(int cameraId) {
1305 android_atomic_write(0, &mBusy[cameraId]);
Igor Murashkinecf17e82012-10-02 16:05:11 -07001306
1307 ALOGV("setCameraFree cameraId=%d", cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001308}
1309
1310// We share the media players for shutter and recording sound for all clients.
1311// A reference count is kept to determine when we will actually release the
1312// media players.
1313
Chih-Chung Changff4f55c2011-10-17 19:03:12 +08001314MediaPlayer* CameraService::newMediaPlayer(const char *file) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001315 MediaPlayer* mp = new MediaPlayer();
Andreas Huber1b86fe02014-01-29 11:13:26 -08001316 if (mp->setDataSource(NULL /* httpService */, file, NULL) == NO_ERROR) {
Eino-Ville Talvala60a78ac2012-01-05 15:34:53 -08001317 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001318 mp->prepare();
1319 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001320 ALOGE("Failed to load CameraService sounds: %s", file);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001321 return NULL;
1322 }
1323 return mp;
1324}
1325
1326void CameraService::loadSound() {
1327 Mutex::Autolock lock(mSoundLock);
1328 LOG1("CameraService::loadSound ref=%d", mSoundRef);
1329 if (mSoundRef++) return;
1330
1331 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
1332 mSoundPlayer[SOUND_RECORDING] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
1333}
1334
1335void CameraService::releaseSound() {
1336 Mutex::Autolock lock(mSoundLock);
1337 LOG1("CameraService::releaseSound ref=%d", mSoundRef);
1338 if (--mSoundRef) return;
1339
1340 for (int i = 0; i < NUM_SOUNDS; i++) {
1341 if (mSoundPlayer[i] != 0) {
1342 mSoundPlayer[i]->disconnect();
1343 mSoundPlayer[i].clear();
1344 }
1345 }
1346}
1347
1348void CameraService::playSound(sound_kind kind) {
1349 LOG1("playSound(%d)", kind);
1350 Mutex::Autolock lock(mSoundLock);
1351 sp<MediaPlayer> player = mSoundPlayer[kind];
1352 if (player != 0) {
Chih-Chung Chang8888a752011-10-20 10:47:26 +08001353 player->seekTo(0);
1354 player->start();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001355 }
1356}
1357
1358// ----------------------------------------------------------------------------
1359
1360CameraService::Client::Client(const sp<CameraService>& cameraService,
Wu-cheng Lib7a67942010-08-17 15:45:37 -07001361 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001362 const String16& clientPackageName,
1363 int cameraId, int cameraFacing,
1364 int clientPid, uid_t clientUid,
1365 int servicePid) :
Igor Murashkin634a5152013-02-20 17:15:11 -08001366 CameraService::BasicClient(cameraService, cameraClient->asBinder(),
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001367 clientPackageName,
1368 cameraId, cameraFacing,
1369 clientPid, clientUid,
1370 servicePid)
Igor Murashkin634a5152013-02-20 17:15:11 -08001371{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001372 int callingPid = getCallingPid();
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001373 LOG1("Client::Client E (pid %d, id %d)", callingPid, cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001374
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001375 mRemoteCallback = cameraClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001376
Mathias Agopian65ab4712010-07-14 17:59:35 -07001377 cameraService->setCameraBusy(cameraId);
1378 cameraService->loadSound();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001379
Wu-cheng Li2fd24402012-02-23 19:01:00 -08001380 LOG1("Client::Client X (pid %d, id %d)", callingPid, cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001381}
1382
Mathias Agopian65ab4712010-07-14 17:59:35 -07001383// tear down the client
1384CameraService::Client::~Client() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07001385 ALOGV("~Client");
Igor Murashkin634a5152013-02-20 17:15:11 -08001386 mDestructionStarted = true;
1387
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001388 mCameraService->releaseSound();
Igor Murashkin036bc3e2012-10-08 15:09:46 -07001389 // unconditionally disconnect. function is idempotent
1390 Client::disconnect();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001391}
1392
Igor Murashkin634a5152013-02-20 17:15:11 -08001393CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001394 const sp<IBinder>& remoteCallback,
1395 const String16& clientPackageName,
1396 int cameraId, int cameraFacing,
1397 int clientPid, uid_t clientUid,
1398 int servicePid):
1399 mClientPackageName(clientPackageName)
Igor Murashkin634a5152013-02-20 17:15:11 -08001400{
1401 mCameraService = cameraService;
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001402 mRemoteBinder = remoteCallback;
Igor Murashkin634a5152013-02-20 17:15:11 -08001403 mCameraId = cameraId;
1404 mCameraFacing = cameraFacing;
1405 mClientPid = clientPid;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001406 mClientUid = clientUid;
Igor Murashkin634a5152013-02-20 17:15:11 -08001407 mServicePid = servicePid;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001408 mOpsActive = false;
Igor Murashkin634a5152013-02-20 17:15:11 -08001409 mDestructionStarted = false;
1410}
1411
1412CameraService::BasicClient::~BasicClient() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07001413 ALOGV("~BasicClient");
Igor Murashkin634a5152013-02-20 17:15:11 -08001414 mDestructionStarted = true;
1415}
1416
1417void CameraService::BasicClient::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07001418 ALOGV("BasicClient::disconnect");
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001419 mCameraService->removeClientByRemote(mRemoteBinder);
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001420
1421 finishCameraOps();
Igor Murashkincba2c162013-03-20 15:56:31 -07001422 // client shouldn't be able to call into us anymore
1423 mClientPid = 0;
Igor Murashkin634a5152013-02-20 17:15:11 -08001424}
1425
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001426status_t CameraService::BasicClient::startCameraOps() {
1427 int32_t res;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001428 // Notify app ops that the camera is not available
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001429 mOpsCallback = new OpsCallback(this);
1430
Igor Murashkine6800ce2013-03-04 17:25:57 -08001431 {
1432 ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
1433 __FUNCTION__, String8(mClientPackageName).string(), mClientUid);
1434 }
1435
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001436 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA,
1437 mClientPackageName, mOpsCallback);
1438 res = mAppOpsManager.startOp(AppOpsManager::OP_CAMERA,
1439 mClientUid, mClientPackageName);
1440
1441 if (res != AppOpsManager::MODE_ALLOWED) {
1442 ALOGI("Camera %d: Access for \"%s\" has been revoked",
1443 mCameraId, String8(mClientPackageName).string());
1444 return PERMISSION_DENIED;
1445 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001446
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001447 mOpsActive = true;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001448
1449 // Transition device availability listeners from PRESENT -> NOT_AVAILABLE
1450 mCameraService->updateStatus(ICameraServiceListener::STATUS_NOT_AVAILABLE,
1451 mCameraId);
1452
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001453 return OK;
1454}
1455
1456status_t CameraService::BasicClient::finishCameraOps() {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001457 // Check if startCameraOps succeeded, and if so, finish the camera op
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001458 if (mOpsActive) {
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001459 // Notify app ops that the camera is available again
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001460 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid,
1461 mClientPackageName);
1462 mOpsActive = false;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001463
1464 // Notify device availability listeners that this camera is available
1465 // again
1466
1467 StatusVector rejectSourceStates;
1468 rejectSourceStates.push_back(ICameraServiceListener::STATUS_NOT_PRESENT);
1469 rejectSourceStates.push_back(ICameraServiceListener::STATUS_ENUMERATING);
1470
1471 // Transition to PRESENT if the camera is not in either of above 2
1472 // states
1473 mCameraService->updateStatus(ICameraServiceListener::STATUS_PRESENT,
1474 mCameraId,
1475 &rejectSourceStates);
1476
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001477 }
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -07001478 // Always stop watching, even if no camera op is active
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001479 mAppOpsManager.stopWatchingMode(mOpsCallback);
1480 mOpsCallback.clear();
1481
1482 return OK;
1483}
1484
1485void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) {
1486 String8 name(packageName);
1487 String8 myName(mClientPackageName);
1488
1489 if (op != AppOpsManager::OP_CAMERA) {
1490 ALOGW("Unexpected app ops notification received: %d", op);
1491 return;
1492 }
1493
1494 int32_t res;
1495 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA,
1496 mClientUid, mClientPackageName);
1497 ALOGV("checkOp returns: %d, %s ", res,
1498 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" :
1499 res == AppOpsManager::MODE_IGNORED ? "IGNORED" :
1500 res == AppOpsManager::MODE_ERRORED ? "ERRORED" :
1501 "UNKNOWN");
1502
1503 if (res != AppOpsManager::MODE_ALLOWED) {
1504 ALOGI("Camera %d: Access for \"%s\" revoked", mCameraId,
1505 myName.string());
1506 // Reset the client PID to allow server-initiated disconnect,
1507 // and to prevent further calls by client.
1508 mClientPid = getCallingPid();
Jianing Weicb0652e2014-03-12 18:29:36 -07001509 CaptureResultExtras resultExtras; // a dummy result (invalid)
1510 notifyError(ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE, resultExtras);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001511 disconnect();
1512 }
1513}
1514
Mathias Agopian65ab4712010-07-14 17:59:35 -07001515// ----------------------------------------------------------------------------
1516
Keun young Parkd8973a72012-03-28 14:13:09 -07001517Mutex* CameraService::Client::getClientLockFromCookie(void* user) {
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001518 return gCameraService->getClientLockById((int)(intptr_t) user);
Keun young Parkd8973a72012-03-28 14:13:09 -07001519}
1520
1521// Provide client pointer for callbacks. Client lock returned from getClientLockFromCookie should
1522// be acquired for this to be safe
1523CameraService::Client* CameraService::Client::getClientFromCookie(void* user) {
Kévin PETIT377b2ec2014-02-03 12:35:36 +00001524 BasicClient *basicClient = gCameraService->getClientByIdUnsafe((int)(intptr_t) user);
Igor Murashkine7ee7632013-06-11 18:10:18 -07001525 // OK: only CameraClient calls this, and they already cast anyway.
1526 Client* client = static_cast<Client*>(basicClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001527
1528 // This could happen if the Client is in the process of shutting down (the
1529 // last strong reference is gone, but the destructor hasn't finished
1530 // stopping the hardware).
Keun young Parkd8973a72012-03-28 14:13:09 -07001531 if (client == NULL) return NULL;
1532
1533 // destruction already started, so should not be accessed
1534 if (client->mDestructionStarted) return NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001535
Mathias Agopian65ab4712010-07-14 17:59:35 -07001536 return client;
1537}
1538
Jianing Weicb0652e2014-03-12 18:29:36 -07001539void CameraService::Client::notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
1540 const CaptureResultExtras& resultExtras) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001541 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001542}
1543
Igor Murashkin036bc3e2012-10-08 15:09:46 -07001544// NOTE: function is idempotent
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -07001545void CameraService::Client::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07001546 ALOGV("Client::disconnect");
Igor Murashkin634a5152013-02-20 17:15:11 -08001547 BasicClient::disconnect();
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -07001548 mCameraService->setCameraFree(mCameraId);
Wu-cheng Lie09591e2010-10-14 20:17:44 +08001549}
1550
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001551CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client):
1552 mClient(client) {
1553}
1554
1555void CameraService::Client::OpsCallback::opChanged(int32_t op,
1556 const String16& packageName) {
1557 sp<BasicClient> client = mClient.promote();
1558 if (client != NULL) {
1559 client->opChanged(op, packageName);
1560 }
1561}
1562
Mathias Agopian65ab4712010-07-14 17:59:35 -07001563// ----------------------------------------------------------------------------
Igor Murashkin634a5152013-02-20 17:15:11 -08001564// IProCamera
1565// ----------------------------------------------------------------------------
1566
1567CameraService::ProClient::ProClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001568 const sp<IProCameraCallbacks>& remoteCallback,
1569 const String16& clientPackageName,
1570 int cameraId,
1571 int cameraFacing,
1572 int clientPid,
1573 uid_t clientUid,
1574 int servicePid)
1575 : CameraService::BasicClient(cameraService, remoteCallback->asBinder(),
1576 clientPackageName, cameraId, cameraFacing,
1577 clientPid, clientUid, servicePid)
Igor Murashkin634a5152013-02-20 17:15:11 -08001578{
1579 mRemoteCallback = remoteCallback;
1580}
1581
1582CameraService::ProClient::~ProClient() {
Igor Murashkin634a5152013-02-20 17:15:11 -08001583}
1584
Jianing Weicb0652e2014-03-12 18:29:36 -07001585void CameraService::ProClient::notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
1586 const CaptureResultExtras& resultExtras) {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001587 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001588}
1589
Igor Murashkin634a5152013-02-20 17:15:11 -08001590// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -07001591
1592static const int kDumpLockRetries = 50;
1593static const int kDumpLockSleep = 60000;
1594
1595static bool tryLock(Mutex& mutex)
1596{
1597 bool locked = false;
1598 for (int i = 0; i < kDumpLockRetries; ++i) {
1599 if (mutex.tryLock() == NO_ERROR) {
1600 locked = true;
1601 break;
1602 }
1603 usleep(kDumpLockSleep);
1604 }
1605 return locked;
1606}
1607
1608status_t CameraService::dump(int fd, const Vector<String16>& args) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001609 String8 result;
1610 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -07001611 result.appendFormat("Permission Denial: "
Mathias Agopian65ab4712010-07-14 17:59:35 -07001612 "can't dump CameraService from pid=%d, uid=%d\n",
1613 getCallingPid(),
1614 getCallingUid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001615 write(fd, result.string(), result.size());
1616 } else {
1617 bool locked = tryLock(mServiceLock);
1618 // failed to lock - CameraService is probably deadlocked
1619 if (!locked) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -07001620 result.append("CameraService may be deadlocked\n");
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001621 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001622 }
1623
1624 bool hasClient = false;
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001625 if (!mModule) {
1626 result = String8::format("No camera module available!\n");
1627 write(fd, result.string(), result.size());
Kalle Lampila6ec3a152013-04-30 15:27:19 +03001628 if (locked) mServiceLock.unlock();
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001629 return NO_ERROR;
1630 }
1631
1632 result = String8::format("Camera module HAL API version: 0x%x\n",
1633 mModule->common.hal_api_version);
1634 result.appendFormat("Camera module API version: 0x%x\n",
1635 mModule->common.module_api_version);
1636 result.appendFormat("Camera module name: %s\n",
1637 mModule->common.name);
1638 result.appendFormat("Camera module author: %s\n",
1639 mModule->common.author);
1640 result.appendFormat("Number of camera devices: %d\n\n", mNumberOfCameras);
Ruben Brunkf81648e2014-04-17 16:14:57 -07001641
1642 sp<VendorTagDescriptor> desc = VendorTagDescriptor::getGlobalVendorTagDescriptor();
1643 if (desc == NULL) {
1644 result.appendFormat("Vendor tags left unimplemented.\n");
1645 } else {
1646 result.appendFormat("Vendor tag definitions:\n");
1647 }
1648
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001649 write(fd, result.string(), result.size());
Ruben Brunkf81648e2014-04-17 16:14:57 -07001650
1651 if (desc != NULL) {
1652 desc->dump(fd, /*verbosity*/2, /*indentation*/4);
1653 }
1654
Mathias Agopian65ab4712010-07-14 17:59:35 -07001655 for (int i = 0; i < mNumberOfCameras; i++) {
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001656 result = String8::format("Camera %d static information:\n", i);
1657 camera_info info;
1658
1659 status_t rc = mModule->get_camera_info(i, &info);
1660 if (rc != OK) {
1661 result.appendFormat(" Error reading static information!\n");
1662 write(fd, result.string(), result.size());
1663 } else {
1664 result.appendFormat(" Facing: %s\n",
1665 info.facing == CAMERA_FACING_BACK ? "BACK" : "FRONT");
1666 result.appendFormat(" Orientation: %d\n", info.orientation);
1667 int deviceVersion;
1668 if (mModule->common.module_api_version <
1669 CAMERA_MODULE_API_VERSION_2_0) {
1670 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
1671 } else {
1672 deviceVersion = info.device_version;
1673 }
1674 result.appendFormat(" Device version: 0x%x\n", deviceVersion);
1675 if (deviceVersion >= CAMERA_DEVICE_API_VERSION_2_0) {
1676 result.appendFormat(" Device static metadata:\n");
1677 write(fd, result.string(), result.size());
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -07001678 dump_indented_camera_metadata(info.static_camera_characteristics,
Ruben Brunkf81648e2014-04-17 16:14:57 -07001679 fd, /*verbosity*/2, /*indentation*/4);
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001680 } else {
1681 write(fd, result.string(), result.size());
1682 }
1683 }
1684
Igor Murashkine7ee7632013-06-11 18:10:18 -07001685 sp<BasicClient> client = mClient[i].promote();
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001686 if (client == 0) {
1687 result = String8::format(" Device is closed, no client instance\n");
1688 write(fd, result.string(), result.size());
1689 continue;
1690 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001691 hasClient = true;
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001692 result = String8::format(" Device is open. Client instance dump:\n");
1693 write(fd, result.string(), result.size());
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -07001694 client->dump(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001695 }
1696 if (!hasClient) {
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001697 result = String8::format("\nNo active camera clients yet.\n");
1698 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001699 }
1700
1701 if (locked) mServiceLock.unlock();
1702
Igor Murashkinff3e31d2013-10-23 16:40:06 -07001703 // Dump camera traces if there were any
1704 write(fd, "\n", 1);
1705 camera3::CameraTraces::dump(fd, args);
1706
Mathias Agopian65ab4712010-07-14 17:59:35 -07001707 // change logging level
1708 int n = args.size();
1709 for (int i = 0; i + 1 < n; i++) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -07001710 String16 verboseOption("-v");
1711 if (args[i] == verboseOption) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001712 String8 levelStr(args[i+1]);
1713 int level = atoi(levelStr.string());
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001714 result = String8::format("\nSetting log level to %d.\n", level);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001715 setLogLevel(level);
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001716 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001717 }
1718 }
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001719
Mathias Agopian65ab4712010-07-14 17:59:35 -07001720 }
1721 return NO_ERROR;
1722}
1723
Igor Murashkinecf17e82012-10-02 16:05:11 -07001724/*virtual*/void CameraService::binderDied(
1725 const wp<IBinder> &who) {
1726
Igor Murashkin294d0ec2012-10-05 10:44:57 -07001727 /**
1728 * While tempting to promote the wp<IBinder> into a sp,
1729 * it's actually not supported by the binder driver
1730 */
1731
Igor Murashkinecf17e82012-10-02 16:05:11 -07001732 ALOGV("java clients' binder died");
1733
Igor Murashkin634a5152013-02-20 17:15:11 -08001734 sp<BasicClient> cameraClient = getClientByRemote(who);
Igor Murashkinecf17e82012-10-02 16:05:11 -07001735
Igor Murashkin294d0ec2012-10-05 10:44:57 -07001736 if (cameraClient == 0) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001737 ALOGV("java clients' binder death already cleaned up (normal case)");
1738 return;
1739 }
1740
Igor Murashkinecf17e82012-10-02 16:05:11 -07001741 ALOGW("Disconnecting camera client %p since the binder for it "
1742 "died (this pid %d)", cameraClient.get(), getCallingPid());
1743
1744 cameraClient->disconnect();
1745
1746}
1747
Igor Murashkinbfc99152013-02-27 12:55:20 -08001748void CameraService::updateStatus(ICameraServiceListener::Status status,
Igor Murashkin93747b92013-05-01 15:42:20 -07001749 int32_t cameraId,
1750 const StatusVector *rejectSourceStates) {
Igor Murashkinbfc99152013-02-27 12:55:20 -08001751 // do not lock mServiceLock here or can get into a deadlock from
1752 // connect() -> ProClient::disconnect -> updateStatus
1753 Mutex::Autolock lock(mStatusMutex);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001754
1755 ICameraServiceListener::Status oldStatus = mStatusList[cameraId];
1756
1757 mStatusList[cameraId] = status;
1758
1759 if (oldStatus != status) {
1760 ALOGV("%s: Status has changed for camera ID %d from 0x%x to 0x%x",
1761 __FUNCTION__, cameraId, (uint32_t)oldStatus, (uint32_t)status);
1762
Igor Murashkincba2c162013-03-20 15:56:31 -07001763 if (oldStatus == ICameraServiceListener::STATUS_NOT_PRESENT &&
1764 (status != ICameraServiceListener::STATUS_PRESENT &&
1765 status != ICameraServiceListener::STATUS_ENUMERATING)) {
1766
1767 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT"
1768 " or ENUMERATING", __FUNCTION__);
1769 mStatusList[cameraId] = oldStatus;
1770 return;
1771 }
1772
Igor Murashkin93747b92013-05-01 15:42:20 -07001773 if (rejectSourceStates != NULL) {
1774 const StatusVector &rejectList = *rejectSourceStates;
1775 StatusVector::const_iterator it = rejectList.begin();
1776
1777 /**
1778 * Sometimes we want to conditionally do a transition.
1779 * For example if a client disconnects, we want to go to PRESENT
1780 * only if we weren't already in NOT_PRESENT or ENUMERATING.
1781 */
1782 for (; it != rejectList.end(); ++it) {
1783 if (oldStatus == *it) {
1784 ALOGV("%s: Rejecting status transition for Camera ID %d, "
1785 " since the source state was was in one of the bad "
1786 " states.", __FUNCTION__, cameraId);
1787 mStatusList[cameraId] = oldStatus;
1788 return;
1789 }
1790 }
1791 }
1792
Igor Murashkinbfc99152013-02-27 12:55:20 -08001793 /**
1794 * ProClients lose their exclusive lock.
1795 * - Done before the CameraClient can initialize the HAL device,
1796 * since we want to be able to close it before they get to initialize
1797 */
1798 if (status == ICameraServiceListener::STATUS_NOT_AVAILABLE) {
1799 Vector<wp<ProClient> > proClients(mProClientList[cameraId]);
1800 Vector<wp<ProClient> >::const_iterator it;
1801
1802 for (it = proClients.begin(); it != proClients.end(); ++it) {
1803 sp<ProClient> proCl = it->promote();
1804 if (proCl.get() != NULL) {
1805 proCl->onExclusiveLockStolen();
1806 }
1807 }
1808 }
1809
1810 Vector<sp<ICameraServiceListener> >::const_iterator it;
1811 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) {
1812 (*it)->onStatusChanged(status, cameraId);
1813 }
1814 }
1815}
1816
Igor Murashkincba2c162013-03-20 15:56:31 -07001817ICameraServiceListener::Status CameraService::getStatus(int cameraId) const {
1818 if (cameraId < 0 || cameraId >= MAX_CAMERAS) {
1819 ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId);
1820 return ICameraServiceListener::STATUS_UNKNOWN;
1821 }
1822
1823 Mutex::Autolock al(mStatusMutex);
1824 return mStatusList[cameraId];
1825}
1826
Mathias Agopian65ab4712010-07-14 17:59:35 -07001827}; // namespace android