1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "Camera2ClientBase" 18#define ATRACE_TAG ATRACE_TAG_CAMERA 19//#define LOG_NDEBUG 0 20 21#include <inttypes.h> 22 23#include <utils/Log.h> 24#include <utils/Trace.h> 25 26#include <cutils/properties.h> 27#include <gui/Surface.h> 28#include <gui/Surface.h> 29 30#include "common/Camera2ClientBase.h" 31 32#include "api2/CameraDeviceClient.h" 33 34#include "CameraDeviceFactory.h" 35 36namespace android { 37using namespace camera2; 38 39static int getCallingPid() { 40 return IPCThreadState::self()->getCallingPid(); 41} 42 43// Interface used by CameraService 44 45template <typename TClientBase> 46Camera2ClientBase<TClientBase>::Camera2ClientBase( 47 const sp<CameraService>& cameraService, 48 const sp<TCamCallbacks>& remoteCallback, 49 const String16& clientPackageName, 50 int cameraId, 51 int cameraFacing, 52 int clientPid, 53 uid_t clientUid, 54 int servicePid): 55 TClientBase(cameraService, remoteCallback, clientPackageName, 56 cameraId, cameraFacing, clientPid, clientUid, servicePid), 57 mSharedCameraCallbacks(remoteCallback), 58 mDeviceVersion(cameraService->getDeviceVersion(cameraId)) 59{ 60 ALOGI("Camera %d: Opened. Client: %s (PID %d, UID %d)", cameraId, 61 String8(clientPackageName).string(), clientPid, clientUid); 62 63 mInitialClientPid = clientPid; 64 mDevice = CameraDeviceFactory::createDevice(cameraId); 65 LOG_ALWAYS_FATAL_IF(mDevice == 0, "Device should never be NULL here."); 66} 67 68template <typename TClientBase> 69status_t Camera2ClientBase<TClientBase>::checkPid(const char* checkLocation) 70 const { 71 72 int callingPid = getCallingPid(); 73 if (callingPid == TClientBase::mClientPid) return NO_ERROR; 74 75 ALOGE("%s: attempt to use a locked camera from a different process" 76 " (old pid %d, new pid %d)", checkLocation, TClientBase::mClientPid, callingPid); 77 return PERMISSION_DENIED; 78} 79 80template <typename TClientBase> 81status_t Camera2ClientBase<TClientBase>::initialize(CameraModule *module) { 82 ATRACE_CALL(); 83 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, 84 TClientBase::mCameraId); 85 status_t res; 86 87 // Verify ops permissions 88 res = TClientBase::startCameraOps(); 89 if (res != OK) { 90 return res; 91 } 92 93 if (mDevice == NULL) { 94 ALOGE("%s: Camera %d: No device connected", 95 __FUNCTION__, TClientBase::mCameraId); 96 return NO_INIT; 97 } 98 99 res = mDevice->initialize(module); 100 if (res != OK) { 101 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)", 102 __FUNCTION__, TClientBase::mCameraId, strerror(-res), res); 103 return res; 104 } 105 106 res = mDevice->setNotifyCallback(this); 107 108 return OK; 109} 110 111template <typename TClientBase> 112Camera2ClientBase<TClientBase>::~Camera2ClientBase() { 113 ATRACE_CALL(); 114 115 TClientBase::mDestructionStarted = true; 116 117 disconnect(); 118 119 ALOGI("Closed Camera %d. Client was: %s (PID %d, UID %u)", 120 TClientBase::mCameraId, 121 String8(TClientBase::mClientPackageName).string(), 122 mInitialClientPid, TClientBase::mClientUid); 123} 124 125template <typename TClientBase> 126status_t Camera2ClientBase<TClientBase>::dump(int fd, 127 const Vector<String16>& args) { 128 String8 result; 129 result.appendFormat("Camera2ClientBase[%d] (%p) PID: %d, dump:\n", 130 TClientBase::mCameraId, 131 (TClientBase::getRemoteCallback() != NULL ? 132 IInterface::asBinder(TClientBase::getRemoteCallback()).get() : NULL), 133 TClientBase::mClientPid); 134 result.append(" State: "); 135 136 write(fd, result.string(), result.size()); 137 // TODO: print dynamic/request section from most recent requests 138 139 return dumpDevice(fd, args); 140} 141 142template <typename TClientBase> 143status_t Camera2ClientBase<TClientBase>::dumpDevice( 144 int fd, 145 const Vector<String16>& args) { 146 String8 result; 147 148 result = " Device dump:\n"; 149 write(fd, result.string(), result.size()); 150 151 if (!mDevice.get()) { 152 result = " *** Device is detached\n"; 153 write(fd, result.string(), result.size()); 154 return NO_ERROR; 155 } 156 157 status_t res = mDevice->dump(fd, args); 158 if (res != OK) { 159 result = String8::format(" Error dumping device: %s (%d)", 160 strerror(-res), res); 161 write(fd, result.string(), result.size()); 162 } 163 164 return NO_ERROR; 165} 166 167// ICameraClient2BaseUser interface 168 169 170template <typename TClientBase> 171void Camera2ClientBase<TClientBase>::disconnect() { 172 ATRACE_CALL(); 173 Mutex::Autolock icl(mBinderSerializationLock); 174 175 // Allow both client and the media server to disconnect at all times 176 int callingPid = getCallingPid(); 177 if (callingPid != TClientBase::mClientPid && 178 callingPid != TClientBase::mServicePid) return; 179 180 ALOGV("Camera %d: Shutting down", TClientBase::mCameraId); 181 182 detachDevice(); 183 184 CameraService::BasicClient::disconnect(); 185 186 ALOGV("Camera %d: Shut down complete complete", TClientBase::mCameraId); 187} 188 189template <typename TClientBase> 190void Camera2ClientBase<TClientBase>::detachDevice() { 191 if (mDevice == 0) return; 192 mDevice->disconnect(); 193 194 mDevice.clear(); 195 196 ALOGV("Camera %d: Detach complete", TClientBase::mCameraId); 197} 198 199template <typename TClientBase> 200status_t Camera2ClientBase<TClientBase>::connect( 201 const sp<TCamCallbacks>& client) { 202 ATRACE_CALL(); 203 ALOGV("%s: E", __FUNCTION__); 204 Mutex::Autolock icl(mBinderSerializationLock); 205 206 if (TClientBase::mClientPid != 0 && 207 getCallingPid() != TClientBase::mClientPid) { 208 209 ALOGE("%s: Camera %d: Connection attempt from pid %d; " 210 "current locked to pid %d", 211 __FUNCTION__, 212 TClientBase::mCameraId, 213 getCallingPid(), 214 TClientBase::mClientPid); 215 return BAD_VALUE; 216 } 217 218 TClientBase::mClientPid = getCallingPid(); 219 220 TClientBase::mRemoteCallback = client; 221 mSharedCameraCallbacks = client; 222 223 return OK; 224} 225 226/** Device-related methods */ 227 228template <typename TClientBase> 229void Camera2ClientBase<TClientBase>::notifyError( 230 ICameraDeviceCallbacks::CameraErrorCode errorCode, 231 const CaptureResultExtras& resultExtras) { 232 ALOGE("Error condition %d reported by HAL, requestId %" PRId32, errorCode, 233 resultExtras.requestId); 234} 235 236template <typename TClientBase> 237void Camera2ClientBase<TClientBase>::notifyIdle() { 238 ALOGV("Camera device is now idle"); 239} 240 241template <typename TClientBase> 242void Camera2ClientBase<TClientBase>::notifyShutter(const CaptureResultExtras& resultExtras, 243 nsecs_t timestamp) { 244 (void)resultExtras; 245 (void)timestamp; 246 247 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64, 248 __FUNCTION__, resultExtras.requestId, timestamp); 249} 250 251template <typename TClientBase> 252void Camera2ClientBase<TClientBase>::notifyAutoFocus(uint8_t newState, 253 int triggerId) { 254 (void)newState; 255 (void)triggerId; 256 257 ALOGV("%s: Autofocus state now %d, last trigger %d", 258 __FUNCTION__, newState, triggerId); 259 260} 261 262template <typename TClientBase> 263void Camera2ClientBase<TClientBase>::notifyAutoExposure(uint8_t newState, 264 int triggerId) { 265 (void)newState; 266 (void)triggerId; 267 268 ALOGV("%s: Autoexposure state now %d, last trigger %d", 269 __FUNCTION__, newState, triggerId); 270} 271 272template <typename TClientBase> 273void Camera2ClientBase<TClientBase>::notifyAutoWhitebalance(uint8_t newState, 274 int triggerId) { 275 (void)newState; 276 (void)triggerId; 277 278 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d", 279 __FUNCTION__, newState, triggerId); 280} 281 282template <typename TClientBase> 283void Camera2ClientBase<TClientBase>::notifyPrepared(int streamId) { 284 (void)streamId; 285 286 ALOGV("%s: Stream %d now prepared", 287 __FUNCTION__, streamId); 288} 289 290template <typename TClientBase> 291int Camera2ClientBase<TClientBase>::getCameraId() const { 292 return TClientBase::mCameraId; 293} 294 295template <typename TClientBase> 296int Camera2ClientBase<TClientBase>::getCameraDeviceVersion() const { 297 return mDeviceVersion; 298} 299 300template <typename TClientBase> 301const sp<CameraDeviceBase>& Camera2ClientBase<TClientBase>::getCameraDevice() { 302 return mDevice; 303} 304 305template <typename TClientBase> 306const sp<CameraService>& Camera2ClientBase<TClientBase>::getCameraService() { 307 return TClientBase::mCameraService; 308} 309 310template <typename TClientBase> 311Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::Lock( 312 SharedCameraCallbacks &client) : 313 314 mRemoteCallback(client.mRemoteCallback), 315 mSharedClient(client) { 316 317 mSharedClient.mRemoteCallbackLock.lock(); 318} 319 320template <typename TClientBase> 321Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::~Lock() { 322 mSharedClient.mRemoteCallbackLock.unlock(); 323} 324 325template <typename TClientBase> 326Camera2ClientBase<TClientBase>::SharedCameraCallbacks::SharedCameraCallbacks( 327 const sp<TCamCallbacks>&client) : 328 329 mRemoteCallback(client) { 330} 331 332template <typename TClientBase> 333typename Camera2ClientBase<TClientBase>::SharedCameraCallbacks& 334Camera2ClientBase<TClientBase>::SharedCameraCallbacks::operator=( 335 const sp<TCamCallbacks>&client) { 336 337 Mutex::Autolock l(mRemoteCallbackLock); 338 mRemoteCallback = client; 339 return *this; 340} 341 342template <typename TClientBase> 343void Camera2ClientBase<TClientBase>::SharedCameraCallbacks::clear() { 344 Mutex::Autolock l(mRemoteCallbackLock); 345 mRemoteCallback.clear(); 346} 347 348template class Camera2ClientBase<CameraService::Client>; 349template class Camera2ClientBase<CameraDeviceClientBase>; 350 351} // namespace android 352