camera/Camera.cpp

   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_NDEBUG 0
  19 #define LOG_TAG "Camera"
  20 #include <utils/Log.h>
  21 #include <utils/threads.h>
  22 #include <utils/String16.h>
  23 #include <binder/IPCThreadState.h>
  24 #include <binder/IServiceManager.h>
  25 #include <binder/IMemory.h>
  26
  27 #include <Camera.h>
  28 #include <ICameraRecordingProxyListener.h>
  29 #include <android/hardware/ICameraService.h>
  30 #include <android/hardware/ICamera.h>
  31
  32 #include <gui/IGraphicBufferProducer.h>
  33 #include <gui/Surface.h>
  34
  35 namespace android {
  36
  37 Camera::Camera(int cameraId)
  38     : CameraBase(cameraId)
  39 {
  40 }
  41
  42 CameraTraits<Camera>::TCamConnectService CameraTraits<Camera>::fnConnectService =
  43         &::android::hardware::ICameraService::connect;
  44
  45 // construct a camera client from an existing camera remote
  46 sp<Camera> Camera::create(const sp<::android::hardware::ICamera>& camera)
  47 {
  48      ALOGV("create");
  49      if (camera == 0) {
  50          ALOGE("camera remote is a NULL pointer");
  51          return 0;
  52      }
  53
  54     sp<Camera> c = new Camera(-1);
  55     if (camera->connect(c) == NO_ERROR) {
  56         c->mStatus = NO_ERROR;
  57         c->mCamera = camera;
  58         IInterface::asBinder(camera)->linkToDeath(c);
  59         return c;
  60     }
  61     return 0;
  62 }
  63
  64 Camera::~Camera()
  65 {
  66     // We don't need to call disconnect() here because if the CameraService
  67     // thinks we are the owner of the hardware, it will hold a (strong)
  68     // reference to us, and we can't possibly be here. We also don't want to
  69     // call disconnect() here if we are in the same process as mediaserver,
  70     // because we may be invoked by CameraService::Client::connect() and will
  71     // deadlock if we call any method of ICamera here.
  72 }
  73
  74 sp<Camera> Camera::connect(int cameraId, const String16& clientPackageName,
  75         int clientUid, int clientPid)
  76 {
  77     return CameraBaseT::connect(cameraId, clientPackageName, clientUid, clientPid);
  78 }
  79
  80 status_t Camera::connectLegacy(int cameraId, int halVersion,
  81         const String16& clientPackageName,
  82         int clientUid,
  83         sp<Camera>& camera)
  84 {
  85     ALOGV("%s: connect legacy camera device", __FUNCTION__);
  86     sp<Camera> c = new Camera(cameraId);
  87     sp<::android::hardware::ICameraClient> cl = c;
  88     status_t status = NO_ERROR;
  89     const sp<::android::hardware::ICameraService>& cs = CameraBaseT::getCameraService();
  90
  91     binder::Status ret;
  92     if (cs != nullptr) {
  93         ret = cs.get()->connectLegacy(cl, cameraId, halVersion, clientPackageName,
  94                 clientUid, /*out*/&(c->mCamera));
  95     }
  96     if (ret.isOk() && c->mCamera != nullptr) {
  97         IInterface::asBinder(c->mCamera)->linkToDeath(c);
  98         c->mStatus = NO_ERROR;
  99         camera = c;
 100     } else {
 101         switch(ret.serviceSpecificErrorCode()) {
 102             case hardware::ICameraService::ERROR_DISCONNECTED:
 103                 status = -ENODEV;
 104                 break;
 105             case hardware::ICameraService::ERROR_CAMERA_IN_USE:
 106                 status = -EBUSY;
 107                 break;
 108             case hardware::ICameraService::ERROR_INVALID_OPERATION:
 109                 status = -EINVAL;
 110                 break;
 111             case hardware::ICameraService::ERROR_MAX_CAMERAS_IN_USE:
 112                 status = -EUSERS;
 113                 break;
 114             case hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT:
 115                 status = BAD_VALUE;
 116                 break;
 117             case hardware::ICameraService::ERROR_DEPRECATED_HAL:
 118                 status = -EOPNOTSUPP;
 119                 break;
 120             case hardware::ICameraService::ERROR_DISABLED:
 121                 status = -EACCES;
 122                 break;
 123             case hardware::ICameraService::ERROR_PERMISSION_DENIED:
 124                 status = PERMISSION_DENIED;
 125                 break;
 126             default:
 127                 status = -EINVAL;
 128                 ALOGW("An error occurred while connecting to camera %d: %s", cameraId,
 129                         (cs != nullptr) ? "Service not available" : ret.toString8().string());
 130                 break;
 131         }
 132         c.clear();
 133     }
 134     return status;
 135 }
 136
 137 status_t Camera::reconnect()
 138 {
 139     ALOGV("reconnect");
 140     sp <::android::hardware::ICamera> c = mCamera;
 141     if (c == 0) return NO_INIT;
 142     return c->connect(this);
 143 }
 144
 145 status_t Camera::lock()
 146 {
 147     sp <::android::hardware::ICamera> c = mCamera;
 148     if (c == 0) return NO_INIT;
 149     return c->lock();
 150 }
 151
 152 status_t Camera::unlock()
 153 {
 154     sp <::android::hardware::ICamera> c = mCamera;
 155     if (c == 0) return NO_INIT;
 156     return c->unlock();
 157 }
 158
 159 // pass the buffered IGraphicBufferProducer to the camera service
 160 status_t Camera::setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)
 161 {
 162     ALOGV("setPreviewTarget(%p)", bufferProducer.get());
 163     sp <::android::hardware::ICamera> c = mCamera;
 164     if (c == 0) return NO_INIT;
 165     ALOGD_IF(bufferProducer == 0, "app passed NULL surface");
 166     return c->setPreviewTarget(bufferProducer);
 167 }
 168
 169 status_t Camera::setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer)
 170 {
 171     ALOGV("setVideoTarget(%p)", bufferProducer.get());
 172     sp <::android::hardware::ICamera> c = mCamera;
 173     if (c == 0) return NO_INIT;
 174     ALOGD_IF(bufferProducer == 0, "app passed NULL video surface");
 175     return c->setVideoTarget(bufferProducer);
 176 }
 177
 178 // start preview mode
 179 status_t Camera::startPreview()
 180 {
 181     ALOGV("startPreview");
 182     sp <::android::hardware::ICamera> c = mCamera;
 183     if (c == 0) return NO_INIT;
 184     return c->startPreview();
 185 }
 186
 187 status_t Camera::setVideoBufferMode(int32_t videoBufferMode)
 188 {
 189     ALOGV("setVideoBufferMode: %d", videoBufferMode);
 190     sp <::android::hardware::ICamera> c = mCamera;
 191     if (c == 0) return NO_INIT;
 192     return c->setVideoBufferMode(videoBufferMode);
 193 }
 194
 195 // start recording mode, must call setPreviewTarget first
 196 status_t Camera::startRecording()
 197 {
 198     ALOGV("startRecording");
 199     sp <::android::hardware::ICamera> c = mCamera;
 200     if (c == 0) return NO_INIT;
 201     return c->startRecording();
 202 }
 203
 204 // stop preview mode
 205 void Camera::stopPreview()
 206 {
 207     ALOGV("stopPreview");
 208     sp <::android::hardware::ICamera> c = mCamera;
 209     if (c == 0) return;
 210     c->stopPreview();
 211 }
 212
 213 // stop recording mode
 214 void Camera::stopRecording()
 215 {
 216     ALOGV("stopRecording");
 217     {
 218         Mutex::Autolock _l(mLock);
 219         mRecordingProxyListener.clear();
 220     }
 221     sp <::android::hardware::ICamera> c = mCamera;
 222     if (c == 0) return;
 223     c->stopRecording();
 224 }
 225
 226 // release a recording frame
 227 void Camera::releaseRecordingFrame(const sp<IMemory>& mem)
 228 {
 229     ALOGV("releaseRecordingFrame");
 230     sp <::android::hardware::ICamera> c = mCamera;
 231     if (c == 0) return;
 232     c->releaseRecordingFrame(mem);
 233 }
 234
 235 void Camera::releaseRecordingFrameHandle(native_handle_t* handle)
 236 {
 237     ALOGV("releaseRecordingFrameHandle");
 238     sp <::android::hardware::ICamera> c = mCamera;
 239     if (c == 0) return;
 240     c->releaseRecordingFrameHandle(handle);
 241 }
 242
 243 // get preview state
 244 bool Camera::previewEnabled()
 245 {
 246     ALOGV("previewEnabled");
 247     sp <::android::hardware::ICamera> c = mCamera;
 248     if (c == 0) return false;
 249     return c->previewEnabled();
 250 }
 251
 252 // get recording state
 253 bool Camera::recordingEnabled()
 254 {
 255     ALOGV("recordingEnabled");
 256     sp <::android::hardware::ICamera> c = mCamera;
 257     if (c == 0) return false;
 258     return c->recordingEnabled();
 259 }
 260
 261 status_t Camera::autoFocus()
 262 {
 263     ALOGV("autoFocus");
 264     sp <::android::hardware::ICamera> c = mCamera;
 265     if (c == 0) return NO_INIT;
 266     return c->autoFocus();
 267 }
 268
 269 status_t Camera::cancelAutoFocus()
 270 {
 271     ALOGV("cancelAutoFocus");
 272     sp <::android::hardware::ICamera> c = mCamera;
 273     if (c == 0) return NO_INIT;
 274     return c->cancelAutoFocus();
 275 }
 276
 277 // take a picture
 278 status_t Camera::takePicture(int msgType)
 279 {
 280     ALOGV("takePicture: 0x%x", msgType);
 281     sp <::android::hardware::ICamera> c = mCamera;
 282     if (c == 0) return NO_INIT;
 283     return c->takePicture(msgType);
 284 }
 285
 286 // set preview/capture parameters - key/value pairs
 287 status_t Camera::setParameters(const String8& params)
 288 {
 289     ALOGV("setParameters");
 290     sp <::android::hardware::ICamera> c = mCamera;
 291     if (c == 0) return NO_INIT;
 292     return c->setParameters(params);
 293 }
 294
 295 // get preview/capture parameters - key/value pairs
 296 String8 Camera::getParameters() const
 297 {
 298     ALOGV("getParameters");
 299     String8 params;
 300     sp <::android::hardware::ICamera> c = mCamera;
 301     if (c != 0) params = mCamera->getParameters();
 302     return params;
 303 }
 304
 305 // send command to camera driver
 306 status_t Camera::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
 307 {
 308     ALOGV("sendCommand");
 309     sp <::android::hardware::ICamera> c = mCamera;
 310     if (c == 0) return NO_INIT;
 311     return c->sendCommand(cmd, arg1, arg2);
 312 }
 313
 314 void Camera::setListener(const sp<CameraListener>& listener)
 315 {
 316     Mutex::Autolock _l(mLock);
 317     mListener = listener;
 318 }
 319
 320 void Camera::setRecordingProxyListener(const sp<ICameraRecordingProxyListener>& listener)
 321 {
 322     Mutex::Autolock _l(mLock);
 323     mRecordingProxyListener = listener;
 324 }
 325
 326 void Camera::setPreviewCallbackFlags(int flag)
 327 {
 328     ALOGV("setPreviewCallbackFlags");
 329     sp <::android::hardware::ICamera> c = mCamera;
 330     if (c == 0) return;
 331     mCamera->setPreviewCallbackFlag(flag);
 332 }
 333
 334 status_t Camera::setPreviewCallbackTarget(
 335         const sp<IGraphicBufferProducer>& callbackProducer)
 336 {
 337     sp <::android::hardware::ICamera> c = mCamera;
 338     if (c == 0) return NO_INIT;
 339     return c->setPreviewCallbackTarget(callbackProducer);
 340 }
 341
 342 // callback from camera service
 343 void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)
 344 {
 345     return CameraBaseT::notifyCallback(msgType, ext1, ext2);
 346 }
 347
 348 // callback from camera service when frame or image is ready
 349 void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
 350                           camera_frame_metadata_t *metadata)
 351 {
 352     sp<CameraListener> listener;
 353     {
 354         Mutex::Autolock _l(mLock);
 355         listener = mListener;
 356     }
 357     if (listener != NULL) {
 358         listener->postData(msgType, dataPtr, metadata);
 359     }
 360 }
 361
 362 // callback from camera service when timestamped frame is ready
 363 void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
 364 {
 365     // If recording proxy listener is registered, forward the frame and return.
 366     // The other listener (mListener) is ignored because the receiver needs to
 367     // call releaseRecordingFrame.
 368     sp<ICameraRecordingProxyListener> proxylistener;
 369     {
 370         Mutex::Autolock _l(mLock);
 371         proxylistener = mRecordingProxyListener;
 372     }
 373     if (proxylistener != NULL) {
 374         proxylistener->dataCallbackTimestamp(timestamp, msgType, dataPtr);
 375         return;
 376     }
 377
 378     sp<CameraListener> listener;
 379     {
 380         Mutex::Autolock _l(mLock);
 381         listener = mListener;
 382     }
 383
 384     if (listener != NULL) {
 385         listener->postDataTimestamp(timestamp, msgType, dataPtr);
 386     } else {
 387         ALOGW("No listener was set. Drop a recording frame.");
 388         releaseRecordingFrame(dataPtr);
 389     }
 390 }
 391
 392 void Camera::recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle)
 393 {
 394     // If recording proxy listener is registered, forward the frame and return.
 395     // The other listener (mListener) is ignored because the receiver needs to
 396     // call releaseRecordingFrameHandle.
 397     sp<ICameraRecordingProxyListener> proxylistener;
 398     {
 399         Mutex::Autolock _l(mLock);
 400         proxylistener = mRecordingProxyListener;
 401     }
 402     if (proxylistener != NULL) {
 403         proxylistener->recordingFrameHandleCallbackTimestamp(timestamp, handle);
 404         return;
 405     }
 406
 407     sp<CameraListener> listener;
 408     {
 409         Mutex::Autolock _l(mLock);
 410         listener = mListener;
 411     }
 412
 413     if (listener != NULL) {
 414         listener->postRecordingFrameHandleTimestamp(timestamp, handle);
 415     } else {
 416         ALOGW("No listener was set. Drop a recording frame.");
 417         releaseRecordingFrameHandle(handle);
 418     }
 419 }
 420
 421 sp<ICameraRecordingProxy> Camera::getRecordingProxy() {
 422     ALOGV("getProxy");
 423     return new RecordingProxy(this);
 424 }
 425
 426 status_t Camera::RecordingProxy::startRecording(const sp<ICameraRecordingProxyListener>& listener)
 427 {
 428     ALOGV("RecordingProxy::startRecording");
 429     mCamera->setRecordingProxyListener(listener);
 430     mCamera->reconnect();
 431     return mCamera->startRecording();
 432 }
 433
 434 void Camera::RecordingProxy::stopRecording()
 435 {
 436     ALOGV("RecordingProxy::stopRecording");
 437     mCamera->stopRecording();
 438 }
 439
 440 void Camera::RecordingProxy::releaseRecordingFrame(const sp<IMemory>& mem)
 441 {
 442     ALOGV("RecordingProxy::releaseRecordingFrame");
 443     mCamera->releaseRecordingFrame(mem);
 444 }
 445
 446 void Camera::RecordingProxy::releaseRecordingFrameHandle(native_handle_t* handle) {
 447     ALOGV("RecordingProxy::releaseRecordingFrameHandle");
 448     mCamera->releaseRecordingFrameHandle(handle);
 449 }
 450
 451 Camera::RecordingProxy::RecordingProxy(const sp<Camera>& camera)
 452 {
 453     mCamera = camera;
 454 }
 455
 456 }; // namespace android