/frameworks/av/services/camera/libcameraservice/CameraService.cpp
C++ | 589 lines | 423 code | 101 blank | 65 comment | 87 complexity | e95b051c4ba1fbeba4e4d1ae5cef9e79 MD5 | raw file
- /*
- **
- ** Copyright (C) 2008, The Android Open Source Project
- **
- ** Licensed under the Apache License, Version 2.0 (the "License");
- ** you may not use this file except in compliance with the License.
- ** You may obtain a copy of the License at
- **
- ** http://www.apache.org/licenses/LICENSE-2.0
- **
- ** Unless required by applicable law or agreed to in writing, software
- ** distributed under the License is distributed on an "AS IS" BASIS,
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ** See the License for the specific language governing permissions and
- ** limitations under the License.
- */
- #define LOG_TAG "CameraService"
- //#define LOG_NDEBUG 0
- #include <stdio.h>
- #include <sys/types.h>
- #include <pthread.h>
- #include <binder/IPCThreadState.h>
- #include <binder/IServiceManager.h>
- #include <binder/MemoryBase.h>
- #include <binder/MemoryHeapBase.h>
- #include <cutils/atomic.h>
- #include <cutils/properties.h>
- #include <gui/SurfaceTextureClient.h>
- #include <gui/Surface.h>
- #include <hardware/hardware.h>
- #include <media/AudioSystem.h>
- #include <media/mediaplayer.h>
- #include <utils/Errors.h>
- #include <utils/Log.h>
- #include <utils/String16.h>
- #include "CameraService.h"
- #include "CameraClient.h"
- #include "Camera2Client.h"
- namespace android {
- // ----------------------------------------------------------------------------
- // Logging support -- this is for debugging only
- // Use "adb shell dumpsys media.camera -v 1" to change it.
- volatile int32_t gLogLevel = 0;
- #define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
- #define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
- static void setLogLevel(int level) {
- android_atomic_write(level, &gLogLevel);
- }
- // ----------------------------------------------------------------------------
- static int getCallingPid() {
- return IPCThreadState::self()->getCallingPid();
- }
- static int getCallingUid() {
- return IPCThreadState::self()->getCallingUid();
- }
- // ----------------------------------------------------------------------------
- // This is ugly and only safe if we never re-create the CameraService, but
- // should be ok for now.
- static CameraService *gCameraService;
- CameraService::CameraService()
- :mSoundRef(0), mModule(0)
- {
- ALOGI("CameraService started (pid=%d)", getpid());
- gCameraService = this;
- }
- void CameraService::onFirstRef()
- {
- BnCameraService::onFirstRef();
- if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
- (const hw_module_t **)&mModule) < 0) {
- ALOGE("Could not load camera HAL module");
- mNumberOfCameras = 0;
- }
- else {
- mNumberOfCameras = mModule->get_number_of_cameras();
- if (mNumberOfCameras > MAX_CAMERAS) {
- ALOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
- mNumberOfCameras, MAX_CAMERAS);
- mNumberOfCameras = MAX_CAMERAS;
- }
- for (int i = 0; i < mNumberOfCameras; i++) {
- setCameraFree(i);
- }
- }
- }
- CameraService::~CameraService() {
- for (int i = 0; i < mNumberOfCameras; i++) {
- if (mBusy[i]) {
- ALOGE("camera %d is still in use in destructor!", i);
- }
- }
- gCameraService = NULL;
- }
- int32_t CameraService::getNumberOfCameras() {
- if(mNumberOfCameras == 0) {
- ALOGE("no camera found before! check again...");
- onFirstRef();
- }
- return mNumberOfCameras;
- }
- status_t CameraService::getCameraInfo(int cameraId,
- struct CameraInfo* cameraInfo) {
- if (!mModule) {
- return NO_INIT;
- }
- if (cameraId < 0 || cameraId >= mNumberOfCameras) {
- return BAD_VALUE;
- }
- struct camera_info info;
- status_t rc = mModule->get_camera_info(cameraId, &info);
- cameraInfo->facing = info.facing;
- cameraInfo->orientation = info.orientation;
- return rc;
- }
- sp<ICamera> CameraService::connect(
- const sp<ICameraClient>& cameraClient, int cameraId) {
- int callingPid = getCallingPid();
- LOG1("CameraService::connect E (pid %d, id %d)", callingPid, cameraId);
- if (!mModule) {
- ALOGE("Camera HAL module not loaded");
- return NULL;
- }
- sp<Client> client;
- if (cameraId < 0 || cameraId >= mNumberOfCameras) {
- ALOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
- callingPid, cameraId);
- return NULL;
- }
- char value[PROPERTY_VALUE_MAX];
- property_get("sys.secpolicy.camera.disabled", value, "0");
- if (strcmp(value, "1") == 0) {
- // Camera is disabled by DevicePolicyManager.
- ALOGI("Camera is disabled. connect X (pid %d) rejected", callingPid);
- return NULL;
- }
- Mutex::Autolock lock(mServiceLock);
- if (mClient[cameraId] != 0) {
- client = mClient[cameraId].promote();
- if (client != 0) {
- if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) {
- LOG1("CameraService::connect X (pid %d) (the same client)",
- callingPid);
- return client;
- } else {
- ALOGW("CameraService::connect X (pid %d) rejected (existing client).",
- callingPid);
- return NULL;
- }
- }
- mClient[cameraId].clear();
- }
- if (mBusy[cameraId]) {
- ALOGW("CameraService::connect X (pid %d) rejected"
- " (camera %d is still busy).", callingPid, cameraId);
- return NULL;
- }
- struct camera_info info;
- if (mModule->get_camera_info(cameraId, &info) != OK) {
- ALOGE("Invalid camera id %d", cameraId);
- return NULL;
- }
- int deviceVersion;
- if (mModule->common.module_api_version == CAMERA_MODULE_API_VERSION_2_0) {
- deviceVersion = info.device_version;
- } else {
- deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
- }
- switch(deviceVersion) {
- case CAMERA_DEVICE_API_VERSION_1_0:
- client = new CameraClient(this, cameraClient, cameraId,
- info.facing, callingPid, getpid());
- break;
- case CAMERA_DEVICE_API_VERSION_2_0:
- client = new Camera2Client(this, cameraClient, cameraId,
- info.facing, callingPid, getpid());
- break;
- default:
- ALOGE("Unknown camera device HAL version: %d", deviceVersion);
- return NULL;
- }
- if (client->initialize(mModule) != OK) {
- return NULL;
- }
- cameraClient->asBinder()->linkToDeath(this);
- mClient[cameraId] = client;
- LOG1("CameraService::connect X (id %d, this pid is %d)", cameraId, getpid());
- return client;
- }
- void CameraService::removeClient(const sp<ICameraClient>& cameraClient) {
- int callingPid = getCallingPid();
- LOG1("CameraService::removeClient E (pid %d)", callingPid);
- // Declare this before the lock to make absolutely sure the
- // destructor won't be called with the lock held.
- Mutex::Autolock lock(mServiceLock);
- int outIndex;
- sp<Client> client = findClientUnsafe(cameraClient->asBinder(), outIndex);
- if (client != 0) {
- // Found our camera, clear and leave.
- LOG1("removeClient: clear camera %d", outIndex);
- mClient[outIndex].clear();
- client->unlinkToDeath(this);
- }
- LOG1("CameraService::removeClient X (pid %d)", callingPid);
- }
- sp<CameraService::Client> CameraService::findClientUnsafe(
- const wp<IBinder>& cameraClient, int& outIndex) {
- sp<Client> client;
- for (int i = 0; i < mNumberOfCameras; i++) {
- // This happens when we have already disconnected (or this is
- // just another unused camera).
- if (mClient[i] == 0) continue;
- // Promote mClient. It can fail if we are called from this path:
- // Client::~Client() -> disconnect() -> removeClient().
- client = mClient[i].promote();
- // Clean up stale client entry
- if (client == NULL) {
- mClient[i].clear();
- continue;
- }
- if (cameraClient == client->getCameraClient()->asBinder()) {
- // Found our camera
- outIndex = i;
- return client;
- }
- }
- outIndex = -1;
- return NULL;
- }
- CameraService::Client* CameraService::getClientByIdUnsafe(int cameraId) {
- if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
- return mClient[cameraId].unsafe_get();
- }
- Mutex* CameraService::getClientLockById(int cameraId) {
- if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
- return &mClientLock[cameraId];
- }
- sp<CameraService::Client> CameraService::getClientByRemote(
- const wp<IBinder>& cameraClient) {
- // Declare this before the lock to make absolutely sure the
- // destructor won't be called with the lock held.
- sp<Client> client;
- Mutex::Autolock lock(mServiceLock);
- int outIndex;
- client = findClientUnsafe(cameraClient, outIndex);
- return client;
- }
- status_t CameraService::onTransact(
- uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
- // Permission checks
- switch (code) {
- case BnCameraService::CONNECT:
- const int pid = getCallingPid();
- const int self_pid = getpid();
- if (pid != self_pid) {
- // we're called from a different process, do the real check
- if (!checkCallingPermission(
- String16("android.permission.CAMERA"))) {
- const int uid = getCallingUid();
- ALOGE("Permission Denial: "
- "can't use the camera pid=%d, uid=%d", pid, uid);
- return PERMISSION_DENIED;
- }
- }
- break;
- }
- return BnCameraService::onTransact(code, data, reply, flags);
- }
- // The reason we need this busy bit is a new CameraService::connect() request
- // may come in while the previous Client's destructor has not been run or is
- // still running. If the last strong reference of the previous Client is gone
- // but the destructor has not been finished, we should not allow the new Client
- // to be created because we need to wait for the previous Client to tear down
- // the hardware first.
- void CameraService::setCameraBusy(int cameraId) {
- android_atomic_write(1, &mBusy[cameraId]);
- ALOGV("setCameraBusy cameraId=%d", cameraId);
- }
- void CameraService::setCameraFree(int cameraId) {
- android_atomic_write(0, &mBusy[cameraId]);
- ALOGV("setCameraFree cameraId=%d", cameraId);
- }
- // We share the media players for shutter and recording sound for all clients.
- // A reference count is kept to determine when we will actually release the
- // media players.
- MediaPlayer* CameraService::newMediaPlayer(const char *file) {
- MediaPlayer* mp = new MediaPlayer();
- if (mp->setDataSource(file, NULL) == NO_ERROR) {
- mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
- mp->prepare();
- } else {
- ALOGE("Failed to load CameraService sounds: %s", file);
- return NULL;
- }
- return mp;
- }
- void CameraService::loadSound() {
- Mutex::Autolock lock(mSoundLock);
- LOG1("CameraService::loadSound ref=%d", mSoundRef);
- if (mSoundRef++) return;
- mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
- mSoundPlayer[SOUND_RECORDING] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
- }
- void CameraService::releaseSound() {
- Mutex::Autolock lock(mSoundLock);
- LOG1("CameraService::releaseSound ref=%d", mSoundRef);
- if (--mSoundRef) return;
- for (int i = 0; i < NUM_SOUNDS; i++) {
- if (mSoundPlayer[i] != 0) {
- mSoundPlayer[i]->disconnect();
- mSoundPlayer[i].clear();
- }
- }
- }
- void CameraService::playSound(sound_kind kind) {
- LOG1("playSound(%d)", kind);
- Mutex::Autolock lock(mSoundLock);
- sp<MediaPlayer> player = mSoundPlayer[kind];
- if (player != 0) {
- player->seekTo(0);
- player->start();
- }
- }
- // ----------------------------------------------------------------------------
- CameraService::Client::Client(const sp<CameraService>& cameraService,
- const sp<ICameraClient>& cameraClient,
- int cameraId, int cameraFacing, int clientPid, int servicePid) {
- int callingPid = getCallingPid();
- LOG1("Client::Client E (pid %d, id %d)", callingPid, cameraId);
- mCameraService = cameraService;
- mCameraClient = cameraClient;
- mCameraId = cameraId;
- mCameraFacing = cameraFacing;
- mClientPid = clientPid;
- mServicePid = servicePid;
- mDestructionStarted = false;
- cameraService->setCameraBusy(cameraId);
- cameraService->loadSound();
- LOG1("Client::Client X (pid %d, id %d)", callingPid, cameraId);
- }
- // tear down the client
- CameraService::Client::~Client() {
- mCameraService->releaseSound();
- // unconditionally disconnect. function is idempotent
- Client::disconnect();
- }
- // ----------------------------------------------------------------------------
- Mutex* CameraService::Client::getClientLockFromCookie(void* user) {
- return gCameraService->getClientLockById((int) user);
- }
- // Provide client pointer for callbacks. Client lock returned from getClientLockFromCookie should
- // be acquired for this to be safe
- CameraService::Client* CameraService::Client::getClientFromCookie(void* user) {
- Client* client = gCameraService->getClientByIdUnsafe((int) user);
- // This could happen if the Client is in the process of shutting down (the
- // last strong reference is gone, but the destructor hasn't finished
- // stopping the hardware).
- if (client == NULL) return NULL;
- // destruction already started, so should not be accessed
- if (client->mDestructionStarted) return NULL;
- return client;
- }
- // NOTE: function is idempotent
- void CameraService::Client::disconnect() {
- mCameraService->removeClient(mCameraClient);
- mCameraService->setCameraFree(mCameraId);
- }
- // ----------------------------------------------------------------------------
- static const int kDumpLockRetries = 50;
- static const int kDumpLockSleep = 60000;
- static bool tryLock(Mutex& mutex)
- {
- bool locked = false;
- for (int i = 0; i < kDumpLockRetries; ++i) {
- if (mutex.tryLock() == NO_ERROR) {
- locked = true;
- break;
- }
- usleep(kDumpLockSleep);
- }
- return locked;
- }
- status_t CameraService::dump(int fd, const Vector<String16>& args) {
- String8 result;
- if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
- result.appendFormat("Permission Denial: "
- "can't dump CameraService from pid=%d, uid=%d\n",
- getCallingPid(),
- getCallingUid());
- write(fd, result.string(), result.size());
- } else {
- bool locked = tryLock(mServiceLock);
- // failed to lock - CameraService is probably deadlocked
- if (!locked) {
- result.append("CameraService may be deadlocked\n");
- write(fd, result.string(), result.size());
- }
- bool hasClient = false;
- if (!mModule) {
- result = String8::format("No camera module available!\n");
- write(fd, result.string(), result.size());
- return NO_ERROR;
- }
- result = String8::format("Camera module HAL API version: 0x%x\n",
- mModule->common.hal_api_version);
- result.appendFormat("Camera module API version: 0x%x\n",
- mModule->common.module_api_version);
- result.appendFormat("Camera module name: %s\n",
- mModule->common.name);
- result.appendFormat("Camera module author: %s\n",
- mModule->common.author);
- result.appendFormat("Number of camera devices: %d\n\n", mNumberOfCameras);
- write(fd, result.string(), result.size());
- for (int i = 0; i < mNumberOfCameras; i++) {
- result = String8::format("Camera %d static information:\n", i);
- camera_info info;
- status_t rc = mModule->get_camera_info(i, &info);
- if (rc != OK) {
- result.appendFormat(" Error reading static information!\n");
- write(fd, result.string(), result.size());
- } else {
- result.appendFormat(" Facing: %s\n",
- info.facing == CAMERA_FACING_BACK ? "BACK" : "FRONT");
- result.appendFormat(" Orientation: %d\n", info.orientation);
- int deviceVersion;
- if (mModule->common.module_api_version <
- CAMERA_MODULE_API_VERSION_2_0) {
- deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
- } else {
- deviceVersion = info.device_version;
- }
- result.appendFormat(" Device version: 0x%x\n", deviceVersion);
- if (deviceVersion >= CAMERA_DEVICE_API_VERSION_2_0) {
- result.appendFormat(" Device static metadata:\n");
- write(fd, result.string(), result.size());
- dump_indented_camera_metadata(info.static_camera_characteristics,
- fd, 2, 4);
- } else {
- write(fd, result.string(), result.size());
- }
- }
- sp<Client> client = mClient[i].promote();
- if (client == 0) {
- result = String8::format(" Device is closed, no client instance\n");
- write(fd, result.string(), result.size());
- continue;
- }
- hasClient = true;
- result = String8::format(" Device is open. Client instance dump:\n");
- write(fd, result.string(), result.size());
- client->dump(fd, args);
- }
- if (!hasClient) {
- result = String8::format("\nNo active camera clients yet.\n");
- write(fd, result.string(), result.size());
- }
- if (locked) mServiceLock.unlock();
- // change logging level
- int n = args.size();
- for (int i = 0; i + 1 < n; i++) {
- String16 verboseOption("-v");
- if (args[i] == verboseOption) {
- String8 levelStr(args[i+1]);
- int level = atoi(levelStr.string());
- result = String8::format("\nSetting log level to %d.\n", level);
- setLogLevel(level);
- write(fd, result.string(), result.size());
- }
- }
- }
- return NO_ERROR;
- }
- /*virtual*/void CameraService::binderDied(
- const wp<IBinder> &who) {
- /**
- * While tempting to promote the wp<IBinder> into a sp,
- * it's actually not supported by the binder driver
- */
- ALOGV("java clients' binder died");
- sp<Client> cameraClient = getClientByRemote(who);
- if (cameraClient == 0) {
- ALOGV("java clients' binder death already cleaned up (normal case)");
- return;
- }
- ALOGW("Disconnecting camera client %p since the binder for it "
- "died (this pid %d)", cameraClient.get(), getCallingPid());
- cameraClient->disconnect();
- }
- }; // namespace android