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