CameraService.cpp revision 1d88023e1de6b9f370eb4be944dd9c4480d01f11 
1/*
2**
3** Copyright (C) 2008, The Android Open Source Project
4**
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"
19//#define LOG_NDEBUG 0
20
21#include <stdio.h>
22#include <sys/types.h>
23#include <pthread.h>
24
25#include <binder/IPCThreadState.h>
26#include <binder/IServiceManager.h>
27#include <binder/MemoryBase.h>
28#include <binder/MemoryHeapBase.h>
29#include <cutils/atomic.h>
30#include <cutils/properties.h>
31#include <gui/Surface.h>
32#include <hardware/hardware.h>
33#include <media/AudioSystem.h>
34#include <media/mediaplayer.h>
35#include <utils/Errors.h>
36#include <utils/Log.h>
37#include <utils/String16.h>
38
39#include "CameraService.h"
40#include "CameraClient.h"
41#include "Camera2Client.h"
42
43namespace android {
44
45// ----------------------------------------------------------------------------
46// Logging support -- this is for debugging only
47// Use "adb shell dumpsys media.camera -v 1" to change it.
48volatile int32_t gLogLevel = 0;
49
50#define LOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
51#define LOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
52
53static void setLogLevel(int level) {
54    android_atomic_write(level, &gLogLevel);
55}
56
57// ----------------------------------------------------------------------------
58
59static int getCallingPid() {
60    return IPCThreadState::self()->getCallingPid();
61}
62
63static int getCallingUid() {
64    return IPCThreadState::self()->getCallingUid();
65}
66
67// ----------------------------------------------------------------------------
68
69// This is ugly and only safe if we never re-create the CameraService, but
70// should be ok for now.
71static CameraService *gCameraService;
72
73CameraService::CameraService()
74:mSoundRef(0), mModule(0)
75{
76    ALOGI("CameraService started (pid=%d)", getpid());
77    gCameraService = this;
78}
79
80void CameraService::onFirstRef()
81{
82    BnCameraService::onFirstRef();
83
84    if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
85                (const hw_module_t **)&mModule) < 0) {
86        ALOGE("Could not load camera HAL module");
87        mNumberOfCameras = 0;
88    }
89    else {
90        ALOGI("Loaded \"%s\" camera module", mModule->common.name);
91        mNumberOfCameras = mModule->get_number_of_cameras();
92        if (mNumberOfCameras > MAX_CAMERAS) {
93            ALOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
94                    mNumberOfCameras, MAX_CAMERAS);
95            mNumberOfCameras = MAX_CAMERAS;
96        }
97        for (int i = 0; i < mNumberOfCameras; i++) {
98            setCameraFree(i);
99        }
100    }
101}
102
103CameraService::~CameraService() {
104    for (int i = 0; i < mNumberOfCameras; i++) {
105        if (mBusy[i]) {
106            ALOGE("camera %d is still in use in destructor!", i);
107        }
108    }
109
110    gCameraService = NULL;
111}
112
113int32_t CameraService::getNumberOfCameras() {
114    return mNumberOfCameras;
115}
116
117status_t CameraService::getCameraInfo(int cameraId,
118                                      struct CameraInfo* cameraInfo) {
119    if (!mModule) {
120        return NO_INIT;
121    }
122
123    if (cameraId < 0 || cameraId >= mNumberOfCameras) {
124        return BAD_VALUE;
125    }
126
127    struct camera_info info;
128    status_t rc = mModule->get_camera_info(cameraId, &info);
129    cameraInfo->facing = info.facing;
130    cameraInfo->orientation = info.orientation;
131    return rc;
132}
133
134sp<ICamera> CameraService::connect(
135        const sp<ICameraClient>& cameraClient, int cameraId) {
136    int callingPid = getCallingPid();
137
138    LOG1("CameraService::connect E (pid %d, id %d)", callingPid, cameraId);
139
140    if (!mModule) {
141        ALOGE("Camera HAL module not loaded");
142        return NULL;
143    }
144
145    sp<Client> client;
146    if (cameraId < 0 || cameraId >= mNumberOfCameras) {
147        ALOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
148            callingPid, cameraId);
149        return NULL;
150    }
151
152    char value[PROPERTY_VALUE_MAX];
153    property_get("sys.secpolicy.camera.disabled", value, "0");
154    if (strcmp(value, "1") == 0) {
155        // Camera is disabled by DevicePolicyManager.
156        ALOGI("Camera is disabled. connect X (pid %d) rejected", callingPid);
157        return NULL;
158    }
159
160    Mutex::Autolock lock(mServiceLock);
161    if (mClient[cameraId] != 0) {
162        client = mClient[cameraId].promote();
163        if (client != 0) {
164            if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) {
165                LOG1("CameraService::connect X (pid %d) (the same client)",
166                     callingPid);
167                return client;
168            } else {
169                // TODOSC: need to support 1 regular client, multiple shared clients here
170                ALOGW("CameraService::connect X (pid %d) rejected (existing client).",
171                      callingPid);
172                return NULL;
173            }
174        }
175        mClient[cameraId].clear();
176    }
177
178    if (mBusy[cameraId]) {
179        ALOGW("CameraService::connect X (pid %d) rejected"
180                " (camera %d is still busy).", callingPid, cameraId);
181        return NULL;
182    }
183
184    struct camera_info info;
185    if (mModule->get_camera_info(cameraId, &info) != OK) {
186        ALOGE("Invalid camera id %d", cameraId);
187        return NULL;
188    }
189
190    int deviceVersion;
191    if (mModule->common.module_api_version == CAMERA_MODULE_API_VERSION_2_0) {
192        deviceVersion = info.device_version;
193    } else {
194        deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
195    }
196
197    switch(deviceVersion) {
198      case CAMERA_DEVICE_API_VERSION_1_0:
199        client = new CameraClient(this, cameraClient, cameraId,
200                info.facing, callingPid, getpid());
201        break;
202      case CAMERA_DEVICE_API_VERSION_2_0:
203        client = new Camera2Client(this, cameraClient, cameraId,
204                info.facing, callingPid, getpid());
205        break;
206      default:
207        ALOGE("Unknown camera device HAL version: %d", deviceVersion);
208        return NULL;
209    }
210
211    if (client->initialize(mModule) != OK) {
212        return NULL;
213    }
214
215    cameraClient->asBinder()->linkToDeath(this);
216
217    mClient[cameraId] = client;
218    LOG1("CameraService::connect X (id %d, this pid is %d)", cameraId, getpid());
219    return client;
220}
221
222void CameraService::removeClient(const sp<ICameraClient>& cameraClient) {
223    int callingPid = getCallingPid();
224    LOG1("CameraService::removeClient E (pid %d)", callingPid);
225
226    // Declare this before the lock to make absolutely sure the
227    // destructor won't be called with the lock held.
228    Mutex::Autolock lock(mServiceLock);
229
230    int outIndex;
231    sp<Client> client = findClientUnsafe(cameraClient->asBinder(), outIndex);
232
233    if (client != 0) {
234        // Found our camera, clear and leave.
235        LOG1("removeClient: clear camera %d", outIndex);
236        mClient[outIndex].clear();
237
238        client->unlinkToDeath(this);
239    }
240
241    LOG1("CameraService::removeClient X (pid %d)", callingPid);
242}
243
244sp<CameraService::Client> CameraService::findClientUnsafe(
245                        const wp<IBinder>& cameraClient, int& outIndex) {
246    sp<Client> client;
247
248    for (int i = 0; i < mNumberOfCameras; i++) {
249
250        // This happens when we have already disconnected (or this is
251        // just another unused camera).
252        if (mClient[i] == 0) continue;
253
254        // Promote mClient. It can fail if we are called from this path:
255        // Client::~Client() -> disconnect() -> removeClient().
256        client = mClient[i].promote();
257
258        // Clean up stale client entry
259        if (client == NULL) {
260            mClient[i].clear();
261            continue;
262        }
263
264        if (cameraClient == client->getCameraClient()->asBinder()) {
265            // Found our camera
266            outIndex = i;
267            return client;
268        }
269    }
270
271    outIndex = -1;
272    return NULL;
273}
274
275CameraService::Client* CameraService::getClientByIdUnsafe(int cameraId) {
276    if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
277    return mClient[cameraId].unsafe_get();
278}
279
280Mutex* CameraService::getClientLockById(int cameraId) {
281    if (cameraId < 0 || cameraId >= mNumberOfCameras) return NULL;
282    return &mClientLock[cameraId];
283}
284
285sp<CameraService::Client> CameraService::getClientByRemote(
286                                const wp<IBinder>& cameraClient) {
287
288    // Declare this before the lock to make absolutely sure the
289    // destructor won't be called with the lock held.
290    sp<Client> client;
291
292    Mutex::Autolock lock(mServiceLock);
293
294    int outIndex;
295    client = findClientUnsafe(cameraClient, outIndex);
296
297    return client;
298}
299
300status_t CameraService::onTransact(
301    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
302    // Permission checks
303    switch (code) {
304        case BnCameraService::CONNECT:
305            const int pid = getCallingPid();
306            const int self_pid = getpid();
307            if (pid != self_pid) {
308                // we're called from a different process, do the real check
309                if (!checkCallingPermission(
310                        String16("android.permission.CAMERA"))) {
311                    const int uid = getCallingUid();
312                    ALOGE("Permission Denial: "
313                         "can't use the camera pid=%d, uid=%d", pid, uid);
314                    return PERMISSION_DENIED;
315                }
316            }
317            break;
318    }
319
320    return BnCameraService::onTransact(code, data, reply, flags);
321}
322
323// The reason we need this busy bit is a new CameraService::connect() request
324// may come in while the previous Client's destructor has not been run or is
325// still running. If the last strong reference of the previous Client is gone
326// but the destructor has not been finished, we should not allow the new Client
327// to be created because we need to wait for the previous Client to tear down
328// the hardware first.
329void CameraService::setCameraBusy(int cameraId) {
330    android_atomic_write(1, &mBusy[cameraId]);
331
332    ALOGV("setCameraBusy cameraId=%d", cameraId);
333}
334
335void CameraService::setCameraFree(int cameraId) {
336    android_atomic_write(0, &mBusy[cameraId]);
337
338    ALOGV("setCameraFree cameraId=%d", cameraId);
339}
340
341// We share the media players for shutter and recording sound for all clients.
342// A reference count is kept to determine when we will actually release the
343// media players.
344
345MediaPlayer* CameraService::newMediaPlayer(const char *file) {
346    MediaPlayer* mp = new MediaPlayer();
347    if (mp->setDataSource(file, NULL) == NO_ERROR) {
348        mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE);
349        mp->prepare();
350    } else {
351        ALOGE("Failed to load CameraService sounds: %s", file);
352        return NULL;
353    }
354    return mp;
355}
356
357void CameraService::loadSound() {
358    Mutex::Autolock lock(mSoundLock);
359    LOG1("CameraService::loadSound ref=%d", mSoundRef);
360    if (mSoundRef++) return;
361
362    mSoundPlayer[SOUND_SHUTTER] = newMediaPlayer("/system/media/audio/ui/camera_click.ogg");
363    mSoundPlayer[SOUND_RECORDING] = newMediaPlayer("/system/media/audio/ui/VideoRecord.ogg");
364}
365
366void CameraService::releaseSound() {
367    Mutex::Autolock lock(mSoundLock);
368    LOG1("CameraService::releaseSound ref=%d", mSoundRef);
369    if (--mSoundRef) return;
370
371    for (int i = 0; i < NUM_SOUNDS; i++) {
372        if (mSoundPlayer[i] != 0) {
373            mSoundPlayer[i]->disconnect();
374            mSoundPlayer[i].clear();
375        }
376    }
377}
378
379void CameraService::playSound(sound_kind kind) {
380    LOG1("playSound(%d)", kind);
381    Mutex::Autolock lock(mSoundLock);
382    sp<MediaPlayer> player = mSoundPlayer[kind];
383    if (player != 0) {
384        player->seekTo(0);
385        player->start();
386    }
387}
388
389// ----------------------------------------------------------------------------
390
391CameraService::Client::Client(const sp<CameraService>& cameraService,
392        const sp<ICameraClient>& cameraClient,
393        int cameraId, int cameraFacing, int clientPid, int servicePid) {
394    int callingPid = getCallingPid();
395    LOG1("Client::Client E (pid %d, id %d)", callingPid, cameraId);
396
397    mCameraService = cameraService;
398    mCameraClient = cameraClient;
399    mCameraId = cameraId;
400    mCameraFacing = cameraFacing;
401    mClientPid = clientPid;
402    mServicePid = servicePid;
403    mDestructionStarted = false;
404
405    cameraService->setCameraBusy(cameraId);
406    cameraService->loadSound();
407    LOG1("Client::Client X (pid %d, id %d)", callingPid, cameraId);
408}
409
410// tear down the client
411CameraService::Client::~Client() {
412    mCameraService->releaseSound();
413
414    // unconditionally disconnect. function is idempotent
415    Client::disconnect();
416}
417
418// ----------------------------------------------------------------------------
419
420Mutex* CameraService::Client::getClientLockFromCookie(void* user) {
421    return gCameraService->getClientLockById((int) user);
422}
423
424// Provide client pointer for callbacks. Client lock returned from getClientLockFromCookie should
425// be acquired for this to be safe
426CameraService::Client* CameraService::Client::getClientFromCookie(void* user) {
427    Client* client = gCameraService->getClientByIdUnsafe((int) user);
428
429    // This could happen if the Client is in the process of shutting down (the
430    // last strong reference is gone, but the destructor hasn't finished
431    // stopping the hardware).
432    if (client == NULL) return NULL;
433
434    // destruction already started, so should not be accessed
435    if (client->mDestructionStarted) return NULL;
436
437    return client;
438}
439
440// NOTE: function is idempotent
441void CameraService::Client::disconnect() {
442    mCameraService->removeClient(mCameraClient);
443    mCameraService->setCameraFree(mCameraId);
444}
445
446// ----------------------------------------------------------------------------
447
448static const int kDumpLockRetries = 50;
449static const int kDumpLockSleep = 60000;
450
451static bool tryLock(Mutex& mutex)
452{
453    bool locked = false;
454    for (int i = 0; i < kDumpLockRetries; ++i) {
455        if (mutex.tryLock() == NO_ERROR) {
456            locked = true;
457            break;
458        }
459        usleep(kDumpLockSleep);
460    }
461    return locked;
462}
463
464status_t CameraService::dump(int fd, const Vector<String16>& args) {
465    String8 result;
466    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
467        result.appendFormat("Permission Denial: "
468                "can't dump CameraService from pid=%d, uid=%d\n",
469                getCallingPid(),
470                getCallingUid());
471        write(fd, result.string(), result.size());
472    } else {
473        bool locked = tryLock(mServiceLock);
474        // failed to lock - CameraService is probably deadlocked
475        if (!locked) {
476            result.append("CameraService may be deadlocked\n");
477            write(fd, result.string(), result.size());
478        }
479
480        bool hasClient = false;
481        if (!mModule) {
482            result = String8::format("No camera module available!\n");
483            write(fd, result.string(), result.size());
484            return NO_ERROR;
485        }
486
487        result = String8::format("Camera module HAL API version: 0x%x\n",
488                mModule->common.hal_api_version);
489        result.appendFormat("Camera module API version: 0x%x\n",
490                mModule->common.module_api_version);
491        result.appendFormat("Camera module name: %s\n",
492                mModule->common.name);
493        result.appendFormat("Camera module author: %s\n",
494                mModule->common.author);
495        result.appendFormat("Number of camera devices: %d\n\n", mNumberOfCameras);
496        write(fd, result.string(), result.size());
497        for (int i = 0; i < mNumberOfCameras; i++) {
498            result = String8::format("Camera %d static information:\n", i);
499            camera_info info;
500
501            status_t rc = mModule->get_camera_info(i, &info);
502            if (rc != OK) {
503                result.appendFormat("  Error reading static information!\n");
504                write(fd, result.string(), result.size());
505            } else {
506                result.appendFormat("  Facing: %s\n",
507                        info.facing == CAMERA_FACING_BACK ? "BACK" : "FRONT");
508                result.appendFormat("  Orientation: %d\n", info.orientation);
509                int deviceVersion;
510                if (mModule->common.module_api_version <
511                        CAMERA_MODULE_API_VERSION_2_0) {
512                    deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
513                } else {
514                    deviceVersion = info.device_version;
515                }
516                result.appendFormat("  Device version: 0x%x\n", deviceVersion);
517                if (deviceVersion >= CAMERA_DEVICE_API_VERSION_2_0) {
518                    result.appendFormat("  Device static metadata:\n");
519                    write(fd, result.string(), result.size());
520                    dump_indented_camera_metadata(info.static_camera_characteristics,
521                            fd, 2, 4);
522                } else {
523                    write(fd, result.string(), result.size());
524                }
525            }
526
527            sp<Client> client = mClient[i].promote();
528            if (client == 0) {
529                result = String8::format("  Device is closed, no client instance\n");
530                write(fd, result.string(), result.size());
531                continue;
532            }
533            hasClient = true;
534            result = String8::format("  Device is open. Client instance dump:\n");
535            write(fd, result.string(), result.size());
536            client->dump(fd, args);
537        }
538        if (!hasClient) {
539            result = String8::format("\nNo active camera clients yet.\n");
540            write(fd, result.string(), result.size());
541        }
542
543        if (locked) mServiceLock.unlock();
544
545        // change logging level
546        int n = args.size();
547        for (int i = 0; i + 1 < n; i++) {
548            String16 verboseOption("-v");
549            if (args[i] == verboseOption) {
550                String8 levelStr(args[i+1]);
551                int level = atoi(levelStr.string());
552                result = String8::format("\nSetting log level to %d.\n", level);
553                setLogLevel(level);
554                write(fd, result.string(), result.size());
555            }
556        }
557
558    }
559    return NO_ERROR;
560}
561
562/*virtual*/void CameraService::binderDied(
563    const wp<IBinder> &who) {
564
565    /**
566      * While tempting to promote the wp<IBinder> into a sp,
567      * it's actually not supported by the binder driver
568      */
569
570    ALOGV("java clients' binder died");
571
572    sp<Client> cameraClient = getClientByRemote(who);
573
574    if (cameraClient == 0) {
575        ALOGV("java clients' binder death already cleaned up (normal case)");
576        return;
577    }
578
579    ALOGW("Disconnecting camera client %p since the binder for it "
580          "died (this pid %d)", cameraClient.get(), getCallingPid());
581
582    cameraClient->disconnect();
583
584}
585
586}; // namespace android
587