blob: fe16314c3c3eba7d0dd4f76d87a28aa988600b75 [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
2**
3** Copyright (C) 2008, The Android Open Source Project
Mathias Agopian65ab4712010-07-14 17:59:35 -07004**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#define LOG_TAG "CameraService"
Iliyan Malchev8951a972011-04-14 16:55:59 -070019//#define LOG_NDEBUG 0
Mathias Agopian65ab4712010-07-14 17:59:35 -070020
21#include <stdio.h>
22#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>
35#include <media/mediaplayer.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070036#include <utils/Errors.h>
37#include <utils/Log.h>
38#include <utils/String16.h>
39
40#include "CameraService.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070041#include "api1/CameraClient.h"
42#include "api1/Camera2Client.h"
43#include "api_pro/ProCamera2Client.h"
44#include "api2/CameraDeviceClient.h"
Igor Murashkin98e24722013-06-19 19:51:04 -070045#include "CameraDeviceFactory.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070046
47namespace android {
48
49// ----------------------------------------------------------------------------
50// Logging support -- this is for debugging only
51// Use "adb shell dumpsys media.camera -v 1" to change it.
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -070052volatile int32_t gLogLevel = 0;
Mathias Agopian65ab4712010-07-14 17:59:35 -070053
Steve Blockb8a80522011-12-20 16:23:08 +000054#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
55#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
Mathias Agopian65ab4712010-07-14 17:59:35 -070056
57static void setLogLevel(int level) {
58 android_atomic_write(level, &gLogLevel);
59}
60
61// ----------------------------------------------------------------------------
62
63static int getCallingPid() {
64 return IPCThreadState::self()->getCallingPid();
65}
66
67static int getCallingUid() {
68 return IPCThreadState::self()->getCallingUid();
69}
70
Igor Murashkincba2c162013-03-20 15:56:31 -070071extern "C" {
72static void camera_device_status_change(
73 const struct camera_module_callbacks* callbacks,
74 int camera_id,
75 int new_status) {
76 sp<CameraService> cs = const_cast<CameraService*>(
77 static_cast<const CameraService*>(callbacks));
78
79 cs->onDeviceStatusChanged(
80 camera_id,
81 new_status);
82}
83} // extern "C"
84
Mathias Agopian65ab4712010-07-14 17:59:35 -070085// ----------------------------------------------------------------------------
86
87// This is ugly and only safe if we never re-create the CameraService, but
88// should be ok for now.
89static CameraService *gCameraService;
90
91CameraService::CameraService()
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080092 :mSoundRef(0), mModule(0)
Mathias Agopian65ab4712010-07-14 17:59:35 -070093{
Steve Blockdf64d152012-01-04 20:05:49 +000094 ALOGI("CameraService started (pid=%d)", getpid());
Mathias Agopian65ab4712010-07-14 17:59:35 -070095 gCameraService = this;
Igor Murashkinbfc99152013-02-27 12:55:20 -080096
97 for (size_t i = 0; i < MAX_CAMERAS; ++i) {
Igor Murashkincba2c162013-03-20 15:56:31 -070098 mStatusList[i] = ICameraServiceListener::STATUS_PRESENT;
Igor Murashkinbfc99152013-02-27 12:55:20 -080099 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700100
101 this->camera_device_status_change = android::camera_device_status_change;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700102}
103
Iliyan Malchev8951a972011-04-14 16:55:59 -0700104void CameraService::onFirstRef()
105{
Igor Murashkin634a5152013-02-20 17:15:11 -0800106 LOG1("CameraService::onFirstRef");
107
Iliyan Malchev8951a972011-04-14 16:55:59 -0700108 BnCameraService::onFirstRef();
109
110 if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
111 (const hw_module_t **)&mModule) < 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000112 ALOGE("Could not load camera HAL module");
Iliyan Malchev8951a972011-04-14 16:55:59 -0700113 mNumberOfCameras = 0;
114 }
115 else {
Alex Rayc0dd54f2013-02-20 13:39:37 -0800116 ALOGI("Loaded \"%s\" camera module", mModule->common.name);
Iliyan Malchev8951a972011-04-14 16:55:59 -0700117 mNumberOfCameras = mModule->get_number_of_cameras();
118 if (mNumberOfCameras > MAX_CAMERAS) {
Steve Block29357bc2012-01-06 19:20:56 +0000119 ALOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
Iliyan Malchev8951a972011-04-14 16:55:59 -0700120 mNumberOfCameras, MAX_CAMERAS);
121 mNumberOfCameras = MAX_CAMERAS;
122 }
123 for (int i = 0; i < mNumberOfCameras; i++) {
124 setCameraFree(i);
125 }
Igor Murashkincba2c162013-03-20 15:56:31 -0700126
127 if (mModule->common.module_api_version >=
128 CAMERA_MODULE_API_VERSION_2_1) {
129 mModule->set_callbacks(this);
130 }
Igor Murashkin98e24722013-06-19 19:51:04 -0700131
132 CameraDeviceFactory::registerService(this);
Iliyan Malchev8951a972011-04-14 16:55:59 -0700133 }
134}
135
Mathias Agopian65ab4712010-07-14 17:59:35 -0700136CameraService::~CameraService() {
137 for (int i = 0; i < mNumberOfCameras; i++) {
138 if (mBusy[i]) {
Steve Block29357bc2012-01-06 19:20:56 +0000139 ALOGE("camera %d is still in use in destructor!", i);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700140 }
141 }
142
143 gCameraService = NULL;
144}
145
Igor Murashkincba2c162013-03-20 15:56:31 -0700146void CameraService::onDeviceStatusChanged(int cameraId,
147 int newStatus)
148{
149 ALOGI("%s: Status changed for cameraId=%d, newStatus=%d", __FUNCTION__,
150 cameraId, newStatus);
151
152 if (cameraId < 0 || cameraId >= MAX_CAMERAS) {
153 ALOGE("%s: Bad camera ID %d", __FUNCTION__, cameraId);
154 return;
155 }
156
157 if ((int)getStatus(cameraId) == newStatus) {
158 ALOGE("%s: State transition to the same status 0x%x not allowed",
159 __FUNCTION__, (uint32_t)newStatus);
160 return;
161 }
162
163 /* don't do this in updateStatus
164 since it is also called from connect and we could get into a deadlock */
165 if (newStatus == CAMERA_DEVICE_STATUS_NOT_PRESENT) {
166 Vector<sp<BasicClient> > clientsToDisconnect;
167 {
168 Mutex::Autolock al(mServiceLock);
169
170 /* Find all clients that we need to disconnect */
Igor Murashkine7ee7632013-06-11 18:10:18 -0700171 sp<BasicClient> client = mClient[cameraId].promote();
Igor Murashkincba2c162013-03-20 15:56:31 -0700172 if (client.get() != NULL) {
173 clientsToDisconnect.push_back(client);
174 }
175
176 int i = cameraId;
177 for (size_t j = 0; j < mProClientList[i].size(); ++j) {
178 sp<ProClient> cl = mProClientList[i][j].promote();
179 if (cl != NULL) {
180 clientsToDisconnect.push_back(cl);
181 }
182 }
183 }
184
185 /* now disconnect them. don't hold the lock
186 or we can get into a deadlock */
187
188 for (size_t i = 0; i < clientsToDisconnect.size(); ++i) {
189 sp<BasicClient> client = clientsToDisconnect[i];
190
191 client->disconnect();
192 /**
193 * The remote app will no longer be able to call methods on the
194 * client since the client PID will be reset to 0
195 */
196 }
197
198 ALOGV("%s: After unplug, disconnected %d clients",
199 __FUNCTION__, clientsToDisconnect.size());
200 }
201
202 updateStatus(
203 static_cast<ICameraServiceListener::Status>(newStatus), cameraId);
204
205}
206
Mathias Agopian65ab4712010-07-14 17:59:35 -0700207int32_t CameraService::getNumberOfCameras() {
208 return mNumberOfCameras;
209}
210
211status_t CameraService::getCameraInfo(int cameraId,
212 struct CameraInfo* cameraInfo) {
Iliyan Malchev8951a972011-04-14 16:55:59 -0700213 if (!mModule) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700214 return -ENODEV;
Iliyan Malchev8951a972011-04-14 16:55:59 -0700215 }
216
Mathias Agopian65ab4712010-07-14 17:59:35 -0700217 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
218 return BAD_VALUE;
219 }
220
Iliyan Malchev8951a972011-04-14 16:55:59 -0700221 struct camera_info info;
222 status_t rc = mModule->get_camera_info(cameraId, &info);
223 cameraInfo->facing = info.facing;
224 cameraInfo->orientation = info.orientation;
225 return rc;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700226}
227
Igor Murashkin634a5152013-02-20 17:15:11 -0800228int CameraService::getDeviceVersion(int cameraId, int* facing) {
229 struct camera_info info;
230 if (mModule->get_camera_info(cameraId, &info) != OK) {
231 return -1;
232 }
233
234 int deviceVersion;
235 if (mModule->common.module_api_version >= CAMERA_MODULE_API_VERSION_2_0) {
236 deviceVersion = info.device_version;
237 } else {
238 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
239 }
240
241 if (facing) {
242 *facing = info.facing;
243 }
244
245 return deviceVersion;
246}
247
Igor Murashkinbfc99152013-02-27 12:55:20 -0800248bool CameraService::isValidCameraId(int cameraId) {
249 int facing;
250 int deviceVersion = getDeviceVersion(cameraId, &facing);
251
252 switch(deviceVersion) {
253 case CAMERA_DEVICE_API_VERSION_1_0:
254 case CAMERA_DEVICE_API_VERSION_2_0:
255 case CAMERA_DEVICE_API_VERSION_2_1:
256 case CAMERA_DEVICE_API_VERSION_3_0:
257 return true;
258 default:
259 return false;
260 }
261
262 return false;
263}
264
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700265status_t CameraService::validateConnect(int cameraId,
Igor Murashkine6800ce2013-03-04 17:25:57 -0800266 /*inout*/
267 int& clientUid) const {
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800268
Mathias Agopian65ab4712010-07-14 17:59:35 -0700269 int callingPid = getCallingPid();
Tyler Luu5861a9a2011-10-06 00:00:03 -0500270
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800271 if (clientUid == USE_CALLING_UID) {
272 clientUid = getCallingUid();
273 } else {
274 // We only trust our own process to forward client UIDs
275 if (callingPid != getpid()) {
276 ALOGE("CameraService::connect X (pid %d) rejected (don't trust clientUid)",
277 callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700278 return PERMISSION_DENIED;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800279 }
280 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700281
Iliyan Malchev8951a972011-04-14 16:55:59 -0700282 if (!mModule) {
Steve Block29357bc2012-01-06 19:20:56 +0000283 ALOGE("Camera HAL module not loaded");
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700284 return -ENODEV;
Iliyan Malchev8951a972011-04-14 16:55:59 -0700285 }
286
Mathias Agopian65ab4712010-07-14 17:59:35 -0700287 if (cameraId < 0 || cameraId >= mNumberOfCameras) {
Steve Block29357bc2012-01-06 19:20:56 +0000288 ALOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
Mathias Agopian65ab4712010-07-14 17:59:35 -0700289 callingPid, cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700290 return -ENODEV;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700291 }
292
Wu-cheng Lia3355432011-05-20 14:54:25 +0800293 char value[PROPERTY_VALUE_MAX];
294 property_get("sys.secpolicy.camera.disabled", value, "0");
295 if (strcmp(value, "1") == 0) {
296 // Camera is disabled by DevicePolicyManager.
Steve Blockdf64d152012-01-04 20:05:49 +0000297 ALOGI("Camera is disabled. connect X (pid %d) rejected", callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700298 return -EACCES;
Wu-cheng Lia3355432011-05-20 14:54:25 +0800299 }
300
Igor Murashkincba2c162013-03-20 15:56:31 -0700301 ICameraServiceListener::Status currentStatus = getStatus(cameraId);
302 if (currentStatus == ICameraServiceListener::STATUS_NOT_PRESENT) {
303 ALOGI("Camera is not plugged in,"
304 " connect X (pid %d) rejected", callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700305 return -ENODEV;
Igor Murashkincba2c162013-03-20 15:56:31 -0700306 } else if (currentStatus == ICameraServiceListener::STATUS_ENUMERATING) {
307 ALOGI("Camera is enumerating,"
308 " connect X (pid %d) rejected", callingPid);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700309 return -EBUSY;
Igor Murashkincba2c162013-03-20 15:56:31 -0700310 }
311 // Else don't check for STATUS_NOT_AVAILABLE.
312 // -- It's done implicitly in canConnectUnsafe /w the mBusy array
313
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700314 return OK;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800315}
316
317bool CameraService::canConnectUnsafe(int cameraId,
318 const String16& clientPackageName,
319 const sp<IBinder>& remoteCallback,
Igor Murashkine7ee7632013-06-11 18:10:18 -0700320 sp<BasicClient> &client) {
Igor Murashkine6800ce2013-03-04 17:25:57 -0800321 String8 clientName8(clientPackageName);
322 int callingPid = getCallingPid();
323
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800324 if (mClient[cameraId] != 0) {
325 client = mClient[cameraId].promote();
326 if (client != 0) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700327 if (remoteCallback == client->getRemote()) {
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800328 LOG1("CameraService::connect X (pid %d) (the same client)",
329 callingPid);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800330 return true;
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800331 } else {
Igor Murashkine6800ce2013-03-04 17:25:57 -0800332 // TODOSC: need to support 1 regular client,
333 // multiple shared clients here
334 ALOGW("CameraService::connect X (pid %d) rejected"
335 " (existing client).", callingPid);
336 return false;
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800337 }
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800338 }
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800339 mClient[cameraId].clear();
340 }
341
Igor Murashkin634a5152013-02-20 17:15:11 -0800342 /*
343 mBusy is set to false as the last step of the Client destructor,
344 after which it is guaranteed that the Client destructor has finished (
345 including any inherited destructors)
346
347 We only need this for a Client subclasses since we don't allow
348 multiple Clents to be opened concurrently, but multiple BasicClient
349 would be fine
350 */
Wu-cheng Li08ad5ef2012-04-19 12:35:00 +0800351 if (mBusy[cameraId]) {
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800352 ALOGW("CameraService::connect X (pid %d, \"%s\") rejected"
353 " (camera %d is still busy).", callingPid,
354 clientName8.string(), cameraId);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800355 return false;
356 }
357
358 return true;
359}
360
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700361status_t CameraService::connect(
Igor Murashkine6800ce2013-03-04 17:25:57 -0800362 const sp<ICameraClient>& cameraClient,
363 int cameraId,
364 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700365 int clientUid,
366 /*out*/
367 sp<ICamera>& device) {
Igor Murashkine6800ce2013-03-04 17:25:57 -0800368
369 String8 clientName8(clientPackageName);
370 int callingPid = getCallingPid();
371
372 LOG1("CameraService::connect E (pid %d \"%s\", id %d)", callingPid,
373 clientName8.string(), cameraId);
374
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700375 status_t status = validateConnect(cameraId, /*inout*/clientUid);
376 if (status != OK) {
377 return status;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700378 }
379
Igor Murashkine6800ce2013-03-04 17:25:57 -0800380
Igor Murashkine7ee7632013-06-11 18:10:18 -0700381 sp<Client> client;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700382 {
383 Mutex::Autolock lock(mServiceLock);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700384 sp<BasicClient> clientTmp;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700385 if (!canConnectUnsafe(cameraId, clientPackageName,
386 cameraClient->asBinder(),
Igor Murashkine7ee7632013-06-11 18:10:18 -0700387 /*out*/clientTmp)) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700388 return -EBUSY;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700389 } else if (client.get() != NULL) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700390 device = static_cast<Client*>(clientTmp.get());
391 return OK;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700392 }
393
394 int facing = -1;
395 int deviceVersion = getDeviceVersion(cameraId, &facing);
396
397 // If there are other non-exclusive users of the camera,
398 // this will tear them down before we can reuse the camera
399 if (isValidCameraId(cameraId)) {
Igor Murashkincba2c162013-03-20 15:56:31 -0700400 // transition from PRESENT -> NOT_AVAILABLE
Igor Murashkinacd695c2013-03-13 17:23:00 -0700401 updateStatus(ICameraServiceListener::STATUS_NOT_AVAILABLE,
402 cameraId);
403 }
404
405 switch(deviceVersion) {
406 case CAMERA_DEVICE_API_VERSION_1_0:
407 client = new CameraClient(this, cameraClient,
408 clientPackageName, cameraId,
409 facing, callingPid, clientUid, getpid());
410 break;
411 case CAMERA_DEVICE_API_VERSION_2_0:
412 case CAMERA_DEVICE_API_VERSION_2_1:
413 case CAMERA_DEVICE_API_VERSION_3_0:
414 client = new Camera2Client(this, cameraClient,
415 clientPackageName, cameraId,
416 facing, callingPid, clientUid, getpid(),
417 deviceVersion);
418 break;
419 case -1:
420 ALOGE("Invalid camera id %d", cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700421 return BAD_VALUE;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700422 default:
423 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700424 return INVALID_OPERATION;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700425 }
426
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700427 status_t status = connectFinishUnsafe(client, client->getRemote());
428 if (status != OK) {
Igor Murashkinacd695c2013-03-13 17:23:00 -0700429 // this is probably not recoverable.. maybe the client can try again
Igor Murashkincba2c162013-03-20 15:56:31 -0700430 // OK: we can only get here if we were originally in PRESENT state
431 updateStatus(ICameraServiceListener::STATUS_PRESENT, cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700432 return status;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700433 }
434
435 mClient[cameraId] = client;
436 LOG1("CameraService::connect X (id %d, this pid is %d)", cameraId,
437 getpid());
Igor Murashkine6800ce2013-03-04 17:25:57 -0800438 }
Igor Murashkinacd695c2013-03-13 17:23:00 -0700439 // important: release the mutex here so the client can call back
440 // into the service from its destructor (can be at the end of the call)
Igor Murashkinbfc99152013-02-27 12:55:20 -0800441
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700442 device = client;
443 return OK;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700444}
445
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700446status_t CameraService::connectFinishUnsafe(const sp<BasicClient>& client,
447 const sp<IBinder>& remoteCallback) {
448 status_t status = client->initialize(mModule);
449 if (status != OK) {
450 return status;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800451 }
452
Igor Murashkine7ee7632013-06-11 18:10:18 -0700453 remoteCallback->linkToDeath(this);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800454
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700455 return OK;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800456}
457
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700458status_t CameraService::connectPro(
Igor Murashkin634a5152013-02-20 17:15:11 -0800459 const sp<IProCameraCallbacks>& cameraCb,
Igor Murashkinc073ba52013-02-26 14:32:34 -0800460 int cameraId,
461 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700462 int clientUid,
463 /*out*/
464 sp<IProCameraUser>& device)
Igor Murashkin634a5152013-02-20 17:15:11 -0800465{
Igor Murashkinbfc99152013-02-27 12:55:20 -0800466 String8 clientName8(clientPackageName);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700467 int callingPid = getCallingPid();
Igor Murashkin634a5152013-02-20 17:15:11 -0800468
Igor Murashkine6800ce2013-03-04 17:25:57 -0800469 LOG1("CameraService::connectPro E (pid %d \"%s\", id %d)", callingPid,
470 clientName8.string(), cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700471 status_t status = validateConnect(cameraId, /*inout*/clientUid);
472 if (status != OK) {
473 return status;
Igor Murashkin634a5152013-02-20 17:15:11 -0800474 }
475
Igor Murashkinacd695c2013-03-13 17:23:00 -0700476 sp<ProClient> client;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800477 {
Igor Murashkinacd695c2013-03-13 17:23:00 -0700478 Mutex::Autolock lock(mServiceLock);
479 {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700480 sp<BasicClient> client;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700481 if (!canConnectUnsafe(cameraId, clientPackageName,
482 cameraCb->asBinder(),
483 /*out*/client)) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700484 return -EBUSY;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700485 }
486 }
487
488 int facing = -1;
489 int deviceVersion = getDeviceVersion(cameraId, &facing);
490
491 switch(deviceVersion) {
492 case CAMERA_DEVICE_API_VERSION_1_0:
493 ALOGE("Camera id %d uses HALv1, doesn't support ProCamera",
494 cameraId);
Ruben Brunk17963d12013-08-19 15:21:19 -0700495 return -EOPNOTSUPP;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700496 break;
497 case CAMERA_DEVICE_API_VERSION_2_0:
498 case CAMERA_DEVICE_API_VERSION_2_1:
Zhijun He47110052013-07-22 17:34:34 -0700499 case CAMERA_DEVICE_API_VERSION_3_0:
Igor Murashkinacd695c2013-03-13 17:23:00 -0700500 client = new ProCamera2Client(this, cameraCb, String16(),
501 cameraId, facing, callingPid, USE_CALLING_UID, getpid());
502 break;
503 case -1:
504 ALOGE("Invalid camera id %d", cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700505 return BAD_VALUE;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700506 default:
507 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700508 return INVALID_OPERATION;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800509 }
Igor Murashkinacd695c2013-03-13 17:23:00 -0700510
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700511 status_t status = connectFinishUnsafe(client, client->getRemote());
512 if (status != OK) {
513 return status;
Igor Murashkinacd695c2013-03-13 17:23:00 -0700514 }
515
516 mProClientList[cameraId].push(client);
517
518 LOG1("CameraService::connectPro X (id %d, this pid is %d)", cameraId,
519 getpid());
Igor Murashkine6800ce2013-03-04 17:25:57 -0800520 }
Igor Murashkinacd695c2013-03-13 17:23:00 -0700521 // important: release the mutex here so the client can call back
522 // into the service from its destructor (can be at the end of the call)
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700523 device = client;
524 return OK;
Igor Murashkinbfc99152013-02-27 12:55:20 -0800525}
Igor Murashkin634a5152013-02-20 17:15:11 -0800526
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700527status_t CameraService::connectDevice(
Igor Murashkine7ee7632013-06-11 18:10:18 -0700528 const sp<ICameraDeviceCallbacks>& cameraCb,
529 int cameraId,
530 const String16& clientPackageName,
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700531 int clientUid,
532 /*out*/
533 sp<ICameraDeviceUser>& device)
Igor Murashkine7ee7632013-06-11 18:10:18 -0700534{
Igor Murashkine7ee7632013-06-11 18:10:18 -0700535
536 String8 clientName8(clientPackageName);
537 int callingPid = getCallingPid();
538
539 LOG1("CameraService::connectDevice E (pid %d \"%s\", id %d)", callingPid,
540 clientName8.string(), cameraId);
541
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700542 status_t status = validateConnect(cameraId, /*inout*/clientUid);
543 if (status != OK) {
544 return status;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700545 }
546
547 sp<CameraDeviceClient> client;
548 {
549 Mutex::Autolock lock(mServiceLock);
550 {
551 sp<BasicClient> client;
552 if (!canConnectUnsafe(cameraId, clientPackageName,
553 cameraCb->asBinder(),
554 /*out*/client)) {
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700555 return -EBUSY;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700556 }
557 }
558
559 int facing = -1;
560 int deviceVersion = getDeviceVersion(cameraId, &facing);
561
562 // If there are other non-exclusive users of the camera,
563 // this will tear them down before we can reuse the camera
564 if (isValidCameraId(cameraId)) {
565 // transition from PRESENT -> NOT_AVAILABLE
566 updateStatus(ICameraServiceListener::STATUS_NOT_AVAILABLE,
567 cameraId);
568 }
569
570 switch(deviceVersion) {
571 case CAMERA_DEVICE_API_VERSION_1_0:
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700572 ALOGW("Camera using old HAL version: %d", deviceVersion);
Ruben Brunk17963d12013-08-19 15:21:19 -0700573 return -EOPNOTSUPP;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700574 // TODO: don't allow 2.0 Only allow 2.1 and higher
575 case CAMERA_DEVICE_API_VERSION_2_0:
576 case CAMERA_DEVICE_API_VERSION_2_1:
577 case CAMERA_DEVICE_API_VERSION_3_0:
578 client = new CameraDeviceClient(this, cameraCb, String16(),
579 cameraId, facing, callingPid, USE_CALLING_UID, getpid());
580 break;
581 case -1:
582 ALOGE("Invalid camera id %d", cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700583 return BAD_VALUE;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700584 default:
585 ALOGE("Unknown camera device HAL version: %d", deviceVersion);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700586 return INVALID_OPERATION;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700587 }
588
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700589 status_t status = connectFinishUnsafe(client, client->getRemote());
590 if (status != OK) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700591 // this is probably not recoverable.. maybe the client can try again
592 // OK: we can only get here if we were originally in PRESENT state
593 updateStatus(ICameraServiceListener::STATUS_PRESENT, cameraId);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700594 return status;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700595 }
596
597 LOG1("CameraService::connectDevice X (id %d, this pid is %d)", cameraId,
598 getpid());
599
600 mClient[cameraId] = client;
601 }
602 // important: release the mutex here so the client can call back
603 // into the service from its destructor (can be at the end of the call)
604
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700605 device = client;
606 return OK;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700607}
608
609
Igor Murashkinbfc99152013-02-27 12:55:20 -0800610status_t CameraService::addListener(
611 const sp<ICameraServiceListener>& listener) {
612 ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
Igor Murashkin634a5152013-02-20 17:15:11 -0800613
Igor Murashkinbfc99152013-02-27 12:55:20 -0800614 Mutex::Autolock lock(mServiceLock);
615
616 Vector<sp<ICameraServiceListener> >::iterator it, end;
617 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) {
618 if ((*it)->asBinder() == listener->asBinder()) {
619 ALOGW("%s: Tried to add listener %p which was already subscribed",
620 __FUNCTION__, listener.get());
621 return ALREADY_EXISTS;
622 }
623 }
624
625 mListenerList.push_back(listener);
626
Igor Murashkincba2c162013-03-20 15:56:31 -0700627 /* Immediately signal current status to this listener only */
628 {
629 Mutex::Autolock m(mStatusMutex) ;
630 int numCams = getNumberOfCameras();
631 for (int i = 0; i < numCams; ++i) {
632 listener->onStatusChanged(mStatusList[i], i);
633 }
634 }
635
Igor Murashkinbfc99152013-02-27 12:55:20 -0800636 return OK;
637}
638status_t CameraService::removeListener(
639 const sp<ICameraServiceListener>& listener) {
640 ALOGV("%s: Remove listener %p", __FUNCTION__, listener.get());
641
642 Mutex::Autolock lock(mServiceLock);
643
644 Vector<sp<ICameraServiceListener> >::iterator it;
645 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) {
646 if ((*it)->asBinder() == listener->asBinder()) {
647 mListenerList.erase(it);
648 return OK;
649 }
650 }
651
652 ALOGW("%s: Tried to remove a listener %p which was not subscribed",
653 __FUNCTION__, listener.get());
654
655 return BAD_VALUE;
Igor Murashkin634a5152013-02-20 17:15:11 -0800656}
657
658void CameraService::removeClientByRemote(const wp<IBinder>& remoteBinder) {
659 int callingPid = getCallingPid();
660 LOG1("CameraService::removeClientByRemote E (pid %d)", callingPid);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700661
Igor Murashkinecf17e82012-10-02 16:05:11 -0700662 // Declare this before the lock to make absolutely sure the
663 // destructor won't be called with the lock held.
664 Mutex::Autolock lock(mServiceLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700665
Igor Murashkinecf17e82012-10-02 16:05:11 -0700666 int outIndex;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700667 sp<BasicClient> client = findClientUnsafe(remoteBinder, outIndex);
Igor Murashkinecf17e82012-10-02 16:05:11 -0700668
669 if (client != 0) {
670 // Found our camera, clear and leave.
671 LOG1("removeClient: clear camera %d", outIndex);
672 mClient[outIndex].clear();
673
Igor Murashkine7ee7632013-06-11 18:10:18 -0700674 client->getRemote()->unlinkToDeath(this);
Igor Murashkin634a5152013-02-20 17:15:11 -0800675 } else {
676
677 sp<ProClient> clientPro = findProClientUnsafe(remoteBinder);
678
679 if (clientPro != NULL) {
680 // Found our camera, clear and leave.
681 LOG1("removeClient: clear pro %p", clientPro.get());
682
683 clientPro->getRemoteCallback()->asBinder()->unlinkToDeath(this);
684 }
Igor Murashkinecf17e82012-10-02 16:05:11 -0700685 }
686
Igor Murashkin634a5152013-02-20 17:15:11 -0800687 LOG1("CameraService::removeClientByRemote X (pid %d)", callingPid);
688}
689
690sp<CameraService::ProClient> CameraService::findProClientUnsafe(
691 const wp<IBinder>& cameraCallbacksRemote)
692{
693 sp<ProClient> clientPro;
694
695 for (int i = 0; i < mNumberOfCameras; ++i) {
696 Vector<size_t> removeIdx;
697
698 for (size_t j = 0; j < mProClientList[i].size(); ++j) {
699 wp<ProClient> cl = mProClientList[i][j];
700
701 sp<ProClient> clStrong = cl.promote();
702 if (clStrong != NULL && clStrong->getRemote() == cameraCallbacksRemote) {
703 clientPro = clStrong;
704 break;
705 } else if (clStrong == NULL) {
706 // mark to clean up dead ptr
707 removeIdx.push(j);
708 }
709 }
710
711 // remove stale ptrs (in reverse so the indices dont change)
712 for (ssize_t j = (ssize_t)removeIdx.size() - 1; j >= 0; --j) {
713 mProClientList[i].removeAt(removeIdx[j]);
714 }
715
716 }
717
718 return clientPro;
Igor Murashkinecf17e82012-10-02 16:05:11 -0700719}
720
Igor Murashkine7ee7632013-06-11 18:10:18 -0700721sp<CameraService::BasicClient> CameraService::findClientUnsafe(
Igor Murashkin294d0ec2012-10-05 10:44:57 -0700722 const wp<IBinder>& cameraClient, int& outIndex) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700723 sp<BasicClient> client;
Igor Murashkinecf17e82012-10-02 16:05:11 -0700724
725 for (int i = 0; i < mNumberOfCameras; i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700726
727 // This happens when we have already disconnected (or this is
728 // just another unused camera).
729 if (mClient[i] == 0) continue;
730
731 // Promote mClient. It can fail if we are called from this path:
Igor Murashkin634a5152013-02-20 17:15:11 -0800732 // Client::~Client() -> disconnect() -> removeClientByRemote().
Mathias Agopian65ab4712010-07-14 17:59:35 -0700733 client = mClient[i].promote();
734
Igor Murashkinecf17e82012-10-02 16:05:11 -0700735 // Clean up stale client entry
736 if (client == NULL) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700737 mClient[i].clear();
738 continue;
739 }
740
Igor Murashkine7ee7632013-06-11 18:10:18 -0700741 if (cameraClient == client->getRemote()) {
Igor Murashkinecf17e82012-10-02 16:05:11 -0700742 // Found our camera
743 outIndex = i;
744 return client;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700745 }
746 }
747
Igor Murashkinecf17e82012-10-02 16:05:11 -0700748 outIndex = -1;
749 return NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700750}
751
Igor Murashkine7ee7632013-06-11 18:10:18 -0700752CameraService::BasicClient* CameraService::getClientByIdUnsafe(int cameraId) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700753 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
Keun young Parkd8973a72012-03-28 14:13:09 -0700754 return mClient[cameraId].unsafe_get();
755}
756
757Mutex* CameraService::getClientLockById(int cameraId) {
758 if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
759 return &mClientLock[cameraId];
Mathias Agopian65ab4712010-07-14 17:59:35 -0700760}
761
Igor Murashkin634a5152013-02-20 17:15:11 -0800762sp<CameraService::BasicClient> CameraService::getClientByRemote(
Igor Murashkin294d0ec2012-10-05 10:44:57 -0700763 const wp<IBinder>& cameraClient) {
Igor Murashkinecf17e82012-10-02 16:05:11 -0700764
765 // Declare this before the lock to make absolutely sure the
766 // destructor won't be called with the lock held.
Igor Murashkin634a5152013-02-20 17:15:11 -0800767 sp<BasicClient> client;
Igor Murashkinecf17e82012-10-02 16:05:11 -0700768
769 Mutex::Autolock lock(mServiceLock);
770
771 int outIndex;
772 client = findClientUnsafe(cameraClient, outIndex);
773
774 return client;
775}
776
Mathias Agopian65ab4712010-07-14 17:59:35 -0700777status_t CameraService::onTransact(
778 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
779 // Permission checks
780 switch (code) {
781 case BnCameraService::CONNECT:
Igor Murashkin634a5152013-02-20 17:15:11 -0800782 case BnCameraService::CONNECT_PRO:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700783 const int pid = getCallingPid();
784 const int self_pid = getpid();
785 if (pid != self_pid) {
786 // we're called from a different process, do the real check
787 if (!checkCallingPermission(
788 String16("android.permission.CAMERA"))) {
789 const int uid = getCallingUid();
Steve Block29357bc2012-01-06 19:20:56 +0000790 ALOGE("Permission Denial: "
Mathias Agopian65ab4712010-07-14 17:59:35 -0700791 "can't use the camera pid=%d, uid=%d", pid, uid);
792 return PERMISSION_DENIED;
793 }
794 }
795 break;
796 }
797
798 return BnCameraService::onTransact(code, data, reply, flags);
799}
800
801// The reason we need this busy bit is a new CameraService::connect() request
802// may come in while the previous Client's destructor has not been run or is
803// still running. If the last strong reference of the previous Client is gone
804// but the destructor has not been finished, we should not allow the new Client
805// to be created because we need to wait for the previous Client to tear down
806// the hardware first.
807void CameraService::setCameraBusy(int cameraId) {
808 android_atomic_write(1, &mBusy[cameraId]);
Igor Murashkinecf17e82012-10-02 16:05:11 -0700809
810 ALOGV("setCameraBusy cameraId=%d", cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700811}
812
813void CameraService::setCameraFree(int cameraId) {
814 android_atomic_write(0, &mBusy[cameraId]);
Igor Murashkinecf17e82012-10-02 16:05:11 -0700815
816 ALOGV("setCameraFree cameraId=%d", cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700817}
818
819// We share the media players for shutter and recording sound for all clients.
820// A reference count is kept to determine when we will actually release the
821// media players.
822
Chih-Chung Changff4f55c2011-10-17 19:03:12 +0800823MediaPlayer* CameraService::newMediaPlayer(const char *file) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700824 MediaPlayer* mp = new MediaPlayer();
825 if (mp->setDataSource(file, NULL) == NO_ERROR) {
Eino-Ville Talvala60a78ac2012-01-05 15:34:53 -0800826 mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700827 mp->prepare();
828 } else {
Steve Block29357bc2012-01-06 19:20:56 +0000829 ALOGE("Failed to load CameraService sounds: %s", file);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700830 return NULL;
831 }
832 return mp;
833}
834
835void CameraService::loadSound() {
836 Mutex::Autolock lock(mSoundLock);
837 LOG1("CameraService::loadSound ref=%d", mSoundRef);
838 if (mSoundRef++) return;
839
840 mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
841 mSoundPlayer[SOUND_RECORDING] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
842}
843
844void CameraService::releaseSound() {
845 Mutex::Autolock lock(mSoundLock);
846 LOG1("CameraService::releaseSound ref=%d", mSoundRef);
847 if (--mSoundRef) return;
848
849 for (int i = 0; i < NUM_SOUNDS; i++) {
850 if (mSoundPlayer[i] != 0) {
851 mSoundPlayer[i]->disconnect();
852 mSoundPlayer[i].clear();
853 }
854 }
855}
856
857void CameraService::playSound(sound_kind kind) {
858 LOG1("playSound(%d)", kind);
859 Mutex::Autolock lock(mSoundLock);
860 sp<MediaPlayer> player = mSoundPlayer[kind];
861 if (player != 0) {
Chih-Chung Chang8888a752011-10-20 10:47:26 +0800862 player->seekTo(0);
863 player->start();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700864 }
865}
866
867// ----------------------------------------------------------------------------
868
869CameraService::Client::Client(const sp<CameraService>& cameraService,
Wu-cheng Lib7a67942010-08-17 15:45:37 -0700870 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800871 const String16& clientPackageName,
872 int cameraId, int cameraFacing,
873 int clientPid, uid_t clientUid,
874 int servicePid) :
Igor Murashkin634a5152013-02-20 17:15:11 -0800875 CameraService::BasicClient(cameraService, cameraClient->asBinder(),
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800876 clientPackageName,
877 cameraId, cameraFacing,
878 clientPid, clientUid,
879 servicePid)
Igor Murashkin634a5152013-02-20 17:15:11 -0800880{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700881 int callingPid = getCallingPid();
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800882 LOG1("Client::Client E (pid %d, id %d)", callingPid, cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700883
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800884 mRemoteCallback = cameraClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700885
Mathias Agopian65ab4712010-07-14 17:59:35 -0700886 cameraService->setCameraBusy(cameraId);
887 cameraService->loadSound();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800888
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800889 LOG1("Client::Client X (pid %d, id %d)", callingPid, cameraId);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700890}
891
Mathias Agopian65ab4712010-07-14 17:59:35 -0700892// tear down the client
893CameraService::Client::~Client() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700894 ALOGV("~Client");
Igor Murashkin634a5152013-02-20 17:15:11 -0800895 mDestructionStarted = true;
896
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700897 mCameraService->releaseSound();
Igor Murashkin036bc3e2012-10-08 15:09:46 -0700898 // unconditionally disconnect. function is idempotent
899 Client::disconnect();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700900}
901
Igor Murashkin634a5152013-02-20 17:15:11 -0800902CameraService::BasicClient::BasicClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800903 const sp<IBinder>& remoteCallback,
904 const String16& clientPackageName,
905 int cameraId, int cameraFacing,
906 int clientPid, uid_t clientUid,
907 int servicePid):
908 mClientPackageName(clientPackageName)
Igor Murashkin634a5152013-02-20 17:15:11 -0800909{
910 mCameraService = cameraService;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800911 mRemoteBinder = remoteCallback;
Igor Murashkin634a5152013-02-20 17:15:11 -0800912 mCameraId = cameraId;
913 mCameraFacing = cameraFacing;
914 mClientPid = clientPid;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800915 mClientUid = clientUid;
Igor Murashkin634a5152013-02-20 17:15:11 -0800916 mServicePid = servicePid;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800917 mOpsActive = false;
Igor Murashkin634a5152013-02-20 17:15:11 -0800918 mDestructionStarted = false;
919}
920
921CameraService::BasicClient::~BasicClient() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700922 ALOGV("~BasicClient");
Igor Murashkin634a5152013-02-20 17:15:11 -0800923 mDestructionStarted = true;
924}
925
926void CameraService::BasicClient::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700927 ALOGV("BasicClient::disconnect");
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800928 mCameraService->removeClientByRemote(mRemoteBinder);
Igor Murashkincba2c162013-03-20 15:56:31 -0700929 // client shouldn't be able to call into us anymore
930 mClientPid = 0;
Igor Murashkin634a5152013-02-20 17:15:11 -0800931}
932
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800933status_t CameraService::BasicClient::startCameraOps() {
934 int32_t res;
935
936 mOpsCallback = new OpsCallback(this);
937
Igor Murashkine6800ce2013-03-04 17:25:57 -0800938 {
939 ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
940 __FUNCTION__, String8(mClientPackageName).string(), mClientUid);
941 }
942
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800943 mAppOpsManager.startWatchingMode(AppOpsManager::OP_CAMERA,
944 mClientPackageName, mOpsCallback);
945 res = mAppOpsManager.startOp(AppOpsManager::OP_CAMERA,
946 mClientUid, mClientPackageName);
947
948 if (res != AppOpsManager::MODE_ALLOWED) {
949 ALOGI("Camera %d: Access for \"%s\" has been revoked",
950 mCameraId, String8(mClientPackageName).string());
951 return PERMISSION_DENIED;
952 }
953 mOpsActive = true;
954 return OK;
955}
956
957status_t CameraService::BasicClient::finishCameraOps() {
958 if (mOpsActive) {
959 mAppOpsManager.finishOp(AppOpsManager::OP_CAMERA, mClientUid,
960 mClientPackageName);
961 mOpsActive = false;
962 }
963 mAppOpsManager.stopWatchingMode(mOpsCallback);
964 mOpsCallback.clear();
965
966 return OK;
967}
968
969void CameraService::BasicClient::opChanged(int32_t op, const String16& packageName) {
970 String8 name(packageName);
971 String8 myName(mClientPackageName);
972
973 if (op != AppOpsManager::OP_CAMERA) {
974 ALOGW("Unexpected app ops notification received: %d", op);
975 return;
976 }
977
978 int32_t res;
979 res = mAppOpsManager.checkOp(AppOpsManager::OP_CAMERA,
980 mClientUid, mClientPackageName);
981 ALOGV("checkOp returns: %d, %s ", res,
982 res == AppOpsManager::MODE_ALLOWED ? "ALLOWED" :
983 res == AppOpsManager::MODE_IGNORED ? "IGNORED" :
984 res == AppOpsManager::MODE_ERRORED ? "ERRORED" :
985 "UNKNOWN");
986
987 if (res != AppOpsManager::MODE_ALLOWED) {
988 ALOGI("Camera %d: Access for \"%s\" revoked", mCameraId,
989 myName.string());
990 // Reset the client PID to allow server-initiated disconnect,
991 // and to prevent further calls by client.
992 mClientPid = getCallingPid();
993 notifyError();
994 disconnect();
995 }
996}
997
Mathias Agopian65ab4712010-07-14 17:59:35 -0700998// ----------------------------------------------------------------------------
999
Keun young Parkd8973a72012-03-28 14:13:09 -07001000Mutex* CameraService::Client::getClientLockFromCookie(void* user) {
1001 return gCameraService->getClientLockById((int) user);
1002}
1003
1004// Provide client pointer for callbacks. Client lock returned from getClientLockFromCookie should
1005// be acquired for this to be safe
1006CameraService::Client* CameraService::Client::getClientFromCookie(void* user) {
Igor Murashkine7ee7632013-06-11 18:10:18 -07001007 BasicClient *basicClient = gCameraService->getClientByIdUnsafe((int) user);
1008 // OK: only CameraClient calls this, and they already cast anyway.
1009 Client* client = static_cast<Client*>(basicClient);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001010
1011 // This could happen if the Client is in the process of shutting down (the
1012 // last strong reference is gone, but the destructor hasn't finished
1013 // stopping the hardware).
Keun young Parkd8973a72012-03-28 14:13:09 -07001014 if (client == NULL) return NULL;
1015
1016 // destruction already started, so should not be accessed
1017 if (client->mDestructionStarted) return NULL;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001018
Mathias Agopian65ab4712010-07-14 17:59:35 -07001019 return client;
1020}
1021
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001022void CameraService::Client::notifyError() {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001023 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001024}
1025
Igor Murashkin036bc3e2012-10-08 15:09:46 -07001026// NOTE: function is idempotent
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -07001027void CameraService::Client::disconnect() {
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -07001028 ALOGV("Client::disconnect");
Igor Murashkin634a5152013-02-20 17:15:11 -08001029 BasicClient::disconnect();
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -07001030 mCameraService->setCameraFree(mCameraId);
Igor Murashkin93747b92013-05-01 15:42:20 -07001031
1032 StatusVector rejectSourceStates;
1033 rejectSourceStates.push_back(ICameraServiceListener::STATUS_NOT_PRESENT);
1034 rejectSourceStates.push_back(ICameraServiceListener::STATUS_ENUMERATING);
1035
1036 // Transition to PRESENT if the camera is not in either of above 2 states
Igor Murashkincba2c162013-03-20 15:56:31 -07001037 mCameraService->updateStatus(ICameraServiceListener::STATUS_PRESENT,
Igor Murashkin93747b92013-05-01 15:42:20 -07001038 mCameraId,
1039 &rejectSourceStates);
Wu-cheng Lie09591e2010-10-14 20:17:44 +08001040}
1041
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001042CameraService::Client::OpsCallback::OpsCallback(wp<BasicClient> client):
1043 mClient(client) {
1044}
1045
1046void CameraService::Client::OpsCallback::opChanged(int32_t op,
1047 const String16& packageName) {
1048 sp<BasicClient> client = mClient.promote();
1049 if (client != NULL) {
1050 client->opChanged(op, packageName);
1051 }
1052}
1053
Mathias Agopian65ab4712010-07-14 17:59:35 -07001054// ----------------------------------------------------------------------------
Igor Murashkin634a5152013-02-20 17:15:11 -08001055// IProCamera
1056// ----------------------------------------------------------------------------
1057
1058CameraService::ProClient::ProClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001059 const sp<IProCameraCallbacks>& remoteCallback,
1060 const String16& clientPackageName,
1061 int cameraId,
1062 int cameraFacing,
1063 int clientPid,
1064 uid_t clientUid,
1065 int servicePid)
1066 : CameraService::BasicClient(cameraService, remoteCallback->asBinder(),
1067 clientPackageName, cameraId, cameraFacing,
1068 clientPid, clientUid, servicePid)
Igor Murashkin634a5152013-02-20 17:15:11 -08001069{
1070 mRemoteCallback = remoteCallback;
1071}
1072
1073CameraService::ProClient::~ProClient() {
Igor Murashkin634a5152013-02-20 17:15:11 -08001074}
1075
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001076void CameraService::ProClient::notifyError() {
Igor Murashkine6800ce2013-03-04 17:25:57 -08001077 mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_RELEASED, 0);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -08001078}
1079
Igor Murashkin634a5152013-02-20 17:15:11 -08001080// ----------------------------------------------------------------------------
Mathias Agopian65ab4712010-07-14 17:59:35 -07001081
1082static const int kDumpLockRetries = 50;
1083static const int kDumpLockSleep = 60000;
1084
1085static bool tryLock(Mutex& mutex)
1086{
1087 bool locked = false;
1088 for (int i = 0; i < kDumpLockRetries; ++i) {
1089 if (mutex.tryLock() == NO_ERROR) {
1090 locked = true;
1091 break;
1092 }
1093 usleep(kDumpLockSleep);
1094 }
1095 return locked;
1096}
1097
1098status_t CameraService::dump(int fd, const Vector<String16>& args) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001099 String8 result;
1100 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -07001101 result.appendFormat("Permission Denial: "
Mathias Agopian65ab4712010-07-14 17:59:35 -07001102 "can't dump CameraService from pid=%d, uid=%d\n",
1103 getCallingPid(),
1104 getCallingUid());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001105 write(fd, result.string(), result.size());
1106 } else {
1107 bool locked = tryLock(mServiceLock);
1108 // failed to lock - CameraService is probably deadlocked
1109 if (!locked) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -07001110 result.append("CameraService may be deadlocked\n");
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001111 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001112 }
1113
1114 bool hasClient = false;
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001115 if (!mModule) {
1116 result = String8::format("No camera module available!\n");
1117 write(fd, result.string(), result.size());
1118 return NO_ERROR;
1119 }
1120
1121 result = String8::format("Camera module HAL API version: 0x%x\n",
1122 mModule->common.hal_api_version);
1123 result.appendFormat("Camera module API version: 0x%x\n",
1124 mModule->common.module_api_version);
1125 result.appendFormat("Camera module name: %s\n",
1126 mModule->common.name);
1127 result.appendFormat("Camera module author: %s\n",
1128 mModule->common.author);
1129 result.appendFormat("Number of camera devices: %d\n\n", mNumberOfCameras);
1130 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001131 for (int i = 0; i < mNumberOfCameras; i++) {
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001132 result = String8::format("Camera %d static information:\n", i);
1133 camera_info info;
1134
1135 status_t rc = mModule->get_camera_info(i, &info);
1136 if (rc != OK) {
1137 result.appendFormat(" Error reading static information!\n");
1138 write(fd, result.string(), result.size());
1139 } else {
1140 result.appendFormat(" Facing: %s\n",
1141 info.facing == CAMERA_FACING_BACK ? "BACK" : "FRONT");
1142 result.appendFormat(" Orientation: %d\n", info.orientation);
1143 int deviceVersion;
1144 if (mModule->common.module_api_version <
1145 CAMERA_MODULE_API_VERSION_2_0) {
1146 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
1147 } else {
1148 deviceVersion = info.device_version;
1149 }
1150 result.appendFormat(" Device version: 0x%x\n", deviceVersion);
1151 if (deviceVersion >= CAMERA_DEVICE_API_VERSION_2_0) {
1152 result.appendFormat(" Device static metadata:\n");
1153 write(fd, result.string(), result.size());
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -07001154 dump_indented_camera_metadata(info.static_camera_characteristics,
1155 fd, 2, 4);
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001156 } else {
1157 write(fd, result.string(), result.size());
1158 }
1159 }
1160
Igor Murashkine7ee7632013-06-11 18:10:18 -07001161 sp<BasicClient> client = mClient[i].promote();
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001162 if (client == 0) {
1163 result = String8::format(" Device is closed, no client instance\n");
1164 write(fd, result.string(), result.size());
1165 continue;
1166 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001167 hasClient = true;
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001168 result = String8::format(" Device is open. Client instance dump:\n");
1169 write(fd, result.string(), result.size());
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -07001170 client->dump(fd, args);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001171 }
1172 if (!hasClient) {
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001173 result = String8::format("\nNo active camera clients yet.\n");
1174 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001175 }
1176
1177 if (locked) mServiceLock.unlock();
1178
1179 // change logging level
1180 int n = args.size();
1181 for (int i = 0; i + 1 < n; i++) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -07001182 String16 verboseOption("-v");
1183 if (args[i] == verboseOption) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001184 String8 levelStr(args[i+1]);
1185 int level = atoi(levelStr.string());
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001186 result = String8::format("\nSetting log level to %d.\n", level);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001187 setLogLevel(level);
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001188 write(fd, result.string(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001189 }
1190 }
Eino-Ville Talvalaf5926132012-07-17 13:54:20 -07001191
Mathias Agopian65ab4712010-07-14 17:59:35 -07001192 }
1193 return NO_ERROR;
1194}
1195
Igor Murashkinecf17e82012-10-02 16:05:11 -07001196/*virtual*/void CameraService::binderDied(
1197 const wp<IBinder> &who) {
1198
Igor Murashkin294d0ec2012-10-05 10:44:57 -07001199 /**
1200 * While tempting to promote the wp<IBinder> into a sp,
1201 * it's actually not supported by the binder driver
1202 */
1203
Igor Murashkinecf17e82012-10-02 16:05:11 -07001204 ALOGV("java clients' binder died");
1205
Igor Murashkin634a5152013-02-20 17:15:11 -08001206 sp<BasicClient> cameraClient = getClientByRemote(who);
Igor Murashkinecf17e82012-10-02 16:05:11 -07001207
Igor Murashkin294d0ec2012-10-05 10:44:57 -07001208 if (cameraClient == 0) {
Igor Murashkinecf17e82012-10-02 16:05:11 -07001209 ALOGV("java clients' binder death already cleaned up (normal case)");
1210 return;
1211 }
1212
Igor Murashkinecf17e82012-10-02 16:05:11 -07001213 ALOGW("Disconnecting camera client %p since the binder for it "
1214 "died (this pid %d)", cameraClient.get(), getCallingPid());
1215
1216 cameraClient->disconnect();
1217
1218}
1219
Igor Murashkinbfc99152013-02-27 12:55:20 -08001220void CameraService::updateStatus(ICameraServiceListener::Status status,
Igor Murashkin93747b92013-05-01 15:42:20 -07001221 int32_t cameraId,
1222 const StatusVector *rejectSourceStates) {
Igor Murashkinbfc99152013-02-27 12:55:20 -08001223 // do not lock mServiceLock here or can get into a deadlock from
1224 // connect() -> ProClient::disconnect -> updateStatus
1225 Mutex::Autolock lock(mStatusMutex);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001226
1227 ICameraServiceListener::Status oldStatus = mStatusList[cameraId];
1228
1229 mStatusList[cameraId] = status;
1230
1231 if (oldStatus != status) {
1232 ALOGV("%s: Status has changed for camera ID %d from 0x%x to 0x%x",
1233 __FUNCTION__, cameraId, (uint32_t)oldStatus, (uint32_t)status);
1234
Igor Murashkincba2c162013-03-20 15:56:31 -07001235 if (oldStatus == ICameraServiceListener::STATUS_NOT_PRESENT &&
1236 (status != ICameraServiceListener::STATUS_PRESENT &&
1237 status != ICameraServiceListener::STATUS_ENUMERATING)) {
1238
1239 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT"
1240 " or ENUMERATING", __FUNCTION__);
1241 mStatusList[cameraId] = oldStatus;
1242 return;
1243 }
1244
Igor Murashkin93747b92013-05-01 15:42:20 -07001245 if (rejectSourceStates != NULL) {
1246 const StatusVector &rejectList = *rejectSourceStates;
1247 StatusVector::const_iterator it = rejectList.begin();
1248
1249 /**
1250 * Sometimes we want to conditionally do a transition.
1251 * For example if a client disconnects, we want to go to PRESENT
1252 * only if we weren't already in NOT_PRESENT or ENUMERATING.
1253 */
1254 for (; it != rejectList.end(); ++it) {
1255 if (oldStatus == *it) {
1256 ALOGV("%s: Rejecting status transition for Camera ID %d, "
1257 " since the source state was was in one of the bad "
1258 " states.", __FUNCTION__, cameraId);
1259 mStatusList[cameraId] = oldStatus;
1260 return;
1261 }
1262 }
1263 }
1264
Igor Murashkinbfc99152013-02-27 12:55:20 -08001265 /**
1266 * ProClients lose their exclusive lock.
1267 * - Done before the CameraClient can initialize the HAL device,
1268 * since we want to be able to close it before they get to initialize
1269 */
1270 if (status == ICameraServiceListener::STATUS_NOT_AVAILABLE) {
1271 Vector<wp<ProClient> > proClients(mProClientList[cameraId]);
1272 Vector<wp<ProClient> >::const_iterator it;
1273
1274 for (it = proClients.begin(); it != proClients.end(); ++it) {
1275 sp<ProClient> proCl = it->promote();
1276 if (proCl.get() != NULL) {
1277 proCl->onExclusiveLockStolen();
1278 }
1279 }
1280 }
1281
1282 Vector<sp<ICameraServiceListener> >::const_iterator it;
1283 for (it = mListenerList.begin(); it != mListenerList.end(); ++it) {
1284 (*it)->onStatusChanged(status, cameraId);
1285 }
1286 }
1287}
1288
Igor Murashkincba2c162013-03-20 15:56:31 -07001289ICameraServiceListener::Status CameraService::getStatus(int cameraId) const {
1290 if (cameraId < 0 || cameraId >= MAX_CAMERAS) {
1291 ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId);
1292 return ICameraServiceListener::STATUS_UNKNOWN;
1293 }
1294
1295 Mutex::Autolock al(mStatusMutex);
1296 return mStatusList[cameraId];
1297}
1298
Mathias Agopian65ab4712010-07-14 17:59:35 -07001299}; // namespace android