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/Camera.h> 28 #include <camera/ICameraRecordingProxyListener.h> 29 #include <camera/ICameraService.h> 30 #include <camera/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 &ICameraService::connect; 44 45 // construct a camera client from an existing camera remote 46 sp<Camera> Camera::create(const sp<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) 76 { 77 return CameraBaseT::connect(cameraId, clientPackageName, clientUid); 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<ICameraClient> cl = c; 88 status_t status = NO_ERROR; 89 const sp<ICameraService>& cs = CameraBaseT::getCameraService(); 90 91 if (cs != 0) { 92 status = cs.get()->connectLegacy(cl, cameraId, halVersion, clientPackageName, 93 clientUid, /*out*/c->mCamera); 94 } 95 if (status == OK && c->mCamera != 0) { 96 IInterface::asBinder(c->mCamera)->linkToDeath(c); 97 c->mStatus = NO_ERROR; 98 camera = c; 99 } else { 100 ALOGW("An error occurred while connecting to camera %d: %d (%s)", 101 cameraId, status, strerror(-status)); 102 c.clear(); 103 } 104 return status; 105 } 106 107 status_t Camera::reconnect() 108 { 109 ALOGV("reconnect"); 110 sp <ICamera> c = mCamera; 111 if (c == 0) return NO_INIT; 112 return c->connect(this); 113 } 114 115 status_t Camera::lock() 116 { 117 sp <ICamera> c = mCamera; 118 if (c == 0) return NO_INIT; 119 return c->lock(); 120 } 121 122 status_t Camera::unlock() 123 { 124 sp <ICamera> c = mCamera; 125 if (c == 0) return NO_INIT; 126 return c->unlock(); 127 } 128 129 // pass the buffered IGraphicBufferProducer to the camera service 130 status_t Camera::setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer) 131 { 132 ALOGV("setPreviewTarget(%p)", bufferProducer.get()); 133 sp <ICamera> c = mCamera; 134 if (c == 0) return NO_INIT; 135 ALOGD_IF(bufferProducer == 0, "app passed NULL surface"); 136 return c->setPreviewTarget(bufferProducer); 137 } 138 139 // start preview mode 140 status_t Camera::startPreview() 141 { 142 ALOGV("startPreview"); 143 sp <ICamera> c = mCamera; 144 if (c == 0) return NO_INIT; 145 return c->startPreview(); 146 } 147 148 status_t Camera::storeMetaDataInBuffers(bool enabled) 149 { 150 ALOGV("storeMetaDataInBuffers: %s", 151 enabled? "true": "false"); 152 sp <ICamera> c = mCamera; 153 if (c == 0) return NO_INIT; 154 return c->storeMetaDataInBuffers(enabled); 155 } 156 157 // start recording mode, must call setPreviewTarget first 158 status_t Camera::startRecording() 159 { 160 ALOGV("startRecording"); 161 sp <ICamera> c = mCamera; 162 if (c == 0) return NO_INIT; 163 return c->startRecording(); 164 } 165 166 // stop preview mode 167 void Camera::stopPreview() 168 { 169 ALOGV("stopPreview"); 170 sp <ICamera> c = mCamera; 171 if (c == 0) return; 172 c->stopPreview(); 173 } 174 175 // stop recording mode 176 void Camera::stopRecording() 177 { 178 ALOGV("stopRecording"); 179 { 180 Mutex::Autolock _l(mLock); 181 mRecordingProxyListener.clear(); 182 } 183 sp <ICamera> c = mCamera; 184 if (c == 0) return; 185 c->stopRecording(); 186 } 187 188 // release a recording frame 189 void Camera::releaseRecordingFrame(const sp<IMemory>& mem) 190 { 191 ALOGV("releaseRecordingFrame"); 192 sp <ICamera> c = mCamera; 193 if (c == 0) return; 194 c->releaseRecordingFrame(mem); 195 } 196 197 // get preview state 198 bool Camera::previewEnabled() 199 { 200 ALOGV("previewEnabled"); 201 sp <ICamera> c = mCamera; 202 if (c == 0) return false; 203 return c->previewEnabled(); 204 } 205 206 // get recording state 207 bool Camera::recordingEnabled() 208 { 209 ALOGV("recordingEnabled"); 210 sp <ICamera> c = mCamera; 211 if (c == 0) return false; 212 return c->recordingEnabled(); 213 } 214 215 status_t Camera::autoFocus() 216 { 217 ALOGV("autoFocus"); 218 sp <ICamera> c = mCamera; 219 if (c == 0) return NO_INIT; 220 return c->autoFocus(); 221 } 222 223 status_t Camera::cancelAutoFocus() 224 { 225 ALOGV("cancelAutoFocus"); 226 sp <ICamera> c = mCamera; 227 if (c == 0) return NO_INIT; 228 return c->cancelAutoFocus(); 229 } 230 231 // take a picture 232 status_t Camera::takePicture(int msgType) 233 { 234 ALOGV("takePicture: 0x%x", msgType); 235 sp <ICamera> c = mCamera; 236 if (c == 0) return NO_INIT; 237 return c->takePicture(msgType); 238 } 239 240 // set preview/capture parameters - key/value pairs 241 status_t Camera::setParameters(const String8& params) 242 { 243 ALOGV("setParameters"); 244 sp <ICamera> c = mCamera; 245 if (c == 0) return NO_INIT; 246 return c->setParameters(params); 247 } 248 249 // get preview/capture parameters - key/value pairs 250 String8 Camera::getParameters() const 251 { 252 ALOGV("getParameters"); 253 String8 params; 254 sp <ICamera> c = mCamera; 255 if (c != 0) params = mCamera->getParameters(); 256 return params; 257 } 258 259 // send command to camera driver 260 status_t Camera::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) 261 { 262 ALOGV("sendCommand"); 263 sp <ICamera> c = mCamera; 264 if (c == 0) return NO_INIT; 265 return c->sendCommand(cmd, arg1, arg2); 266 } 267 268 void Camera::setListener(const sp<CameraListener>& listener) 269 { 270 Mutex::Autolock _l(mLock); 271 mListener = listener; 272 } 273 274 void Camera::setRecordingProxyListener(const sp<ICameraRecordingProxyListener>& listener) 275 { 276 Mutex::Autolock _l(mLock); 277 mRecordingProxyListener = listener; 278 } 279 280 void Camera::setPreviewCallbackFlags(int flag) 281 { 282 ALOGV("setPreviewCallbackFlags"); 283 sp <ICamera> c = mCamera; 284 if (c == 0) return; 285 mCamera->setPreviewCallbackFlag(flag); 286 } 287 288 status_t Camera::setPreviewCallbackTarget( 289 const sp<IGraphicBufferProducer>& callbackProducer) 290 { 291 sp <ICamera> c = mCamera; 292 if (c == 0) return NO_INIT; 293 return c->setPreviewCallbackTarget(callbackProducer); 294 } 295 296 // callback from camera service 297 void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2) 298 { 299 return CameraBaseT::notifyCallback(msgType, ext1, ext2); 300 } 301 302 // callback from camera service when frame or image is ready 303 void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, 304 camera_frame_metadata_t *metadata) 305 { 306 sp<CameraListener> listener; 307 { 308 Mutex::Autolock _l(mLock); 309 listener = mListener; 310 } 311 if (listener != NULL) { 312 listener->postData(msgType, dataPtr, metadata); 313 } 314 } 315 316 // callback from camera service when timestamped frame is ready 317 void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) 318 { 319 // If recording proxy listener is registered, forward the frame and return. 320 // The other listener (mListener) is ignored because the receiver needs to 321 // call releaseRecordingFrame. 322 sp<ICameraRecordingProxyListener> proxylistener; 323 { 324 Mutex::Autolock _l(mLock); 325 proxylistener = mRecordingProxyListener; 326 } 327 if (proxylistener != NULL) { 328 proxylistener->dataCallbackTimestamp(timestamp, msgType, dataPtr); 329 return; 330 } 331 332 sp<CameraListener> listener; 333 { 334 Mutex::Autolock _l(mLock); 335 listener = mListener; 336 } 337 338 if (listener != NULL) { 339 listener->postDataTimestamp(timestamp, msgType, dataPtr); 340 } else { 341 ALOGW("No listener was set. Drop a recording frame."); 342 releaseRecordingFrame(dataPtr); 343 } 344 } 345 346 sp<ICameraRecordingProxy> Camera::getRecordingProxy() { 347 ALOGV("getProxy"); 348 return new RecordingProxy(this); 349 } 350 351 status_t Camera::RecordingProxy::startRecording(const sp<ICameraRecordingProxyListener>& listener) 352 { 353 ALOGV("RecordingProxy::startRecording"); 354 mCamera->setRecordingProxyListener(listener); 355 mCamera->reconnect(); 356 return mCamera->startRecording(); 357 } 358 359 void Camera::RecordingProxy::stopRecording() 360 { 361 ALOGV("RecordingProxy::stopRecording"); 362 mCamera->stopRecording(); 363 } 364 365 void Camera::RecordingProxy::releaseRecordingFrame(const sp<IMemory>& mem) 366 { 367 ALOGV("RecordingProxy::releaseRecordingFrame"); 368 mCamera->releaseRecordingFrame(mem); 369 } 370 371 Camera::RecordingProxy::RecordingProxy(const sp<Camera>& camera) 372 { 373 mCamera = camera; 374 } 375 376 }; // namespace android 377