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
36 namespace android {
37 using namespace camera2;
38
getCallingPid()39 static int getCallingPid() {
40 return IPCThreadState::self()->getCallingPid();
41 }
42
43 // Interface used by CameraService
44
45 template <typename TClientBase>
Camera2ClientBase(const sp<CameraService> & cameraService,const sp<TCamCallbacks> & remoteCallback,const String16 & clientPackageName,int cameraId,int cameraFacing,int clientPid,uid_t clientUid,int servicePid)46 Camera2ClientBase<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 mDeviceActive(false)
60 {
61 ALOGI("Camera %d: Opened. Client: %s (PID %d, UID %d)", cameraId,
62 String8(clientPackageName).string(), clientPid, clientUid);
63
64 mInitialClientPid = clientPid;
65 mDevice = CameraDeviceFactory::createDevice(cameraId);
66 LOG_ALWAYS_FATAL_IF(mDevice == 0, "Device should never be NULL here.");
67 }
68
69 template <typename TClientBase>
checkPid(const char * checkLocation) const70 status_t Camera2ClientBase<TClientBase>::checkPid(const char* checkLocation)
71 const {
72
73 int callingPid = getCallingPid();
74 if (callingPid == TClientBase::mClientPid) return NO_ERROR;
75
76 ALOGE("%s: attempt to use a locked camera from a different process"
77 " (old pid %d, new pid %d)", checkLocation, TClientBase::mClientPid, callingPid);
78 return PERMISSION_DENIED;
79 }
80
81 template <typename TClientBase>
initialize(CameraModule * module)82 status_t Camera2ClientBase<TClientBase>::initialize(CameraModule *module) {
83 ATRACE_CALL();
84 ALOGV("%s: Initializing client for camera %d", __FUNCTION__,
85 TClientBase::mCameraId);
86 status_t res;
87
88 // Verify ops permissions
89 res = TClientBase::startCameraOps();
90 if (res != OK) {
91 return res;
92 }
93
94 if (mDevice == NULL) {
95 ALOGE("%s: Camera %d: No device connected",
96 __FUNCTION__, TClientBase::mCameraId);
97 return NO_INIT;
98 }
99
100 res = mDevice->initialize(module);
101 if (res != OK) {
102 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
103 __FUNCTION__, TClientBase::mCameraId, strerror(-res), res);
104 return res;
105 }
106
107 res = mDevice->setNotifyCallback(this);
108
109 return OK;
110 }
111
112 template <typename TClientBase>
~Camera2ClientBase()113 Camera2ClientBase<TClientBase>::~Camera2ClientBase() {
114 ATRACE_CALL();
115
116 TClientBase::mDestructionStarted = true;
117
118 disconnect();
119
120 ALOGI("Closed Camera %d. Client was: %s (PID %d, UID %u)",
121 TClientBase::mCameraId,
122 String8(TClientBase::mClientPackageName).string(),
123 mInitialClientPid, TClientBase::mClientUid);
124 }
125
126 template <typename TClientBase>
dumpClient(int fd,const Vector<String16> & args)127 status_t Camera2ClientBase<TClientBase>::dumpClient(int fd,
128 const Vector<String16>& args) {
129 String8 result;
130 result.appendFormat("Camera2ClientBase[%d] (%p) PID: %d, dump:\n",
131 TClientBase::mCameraId,
132 (TClientBase::getRemoteCallback() != NULL ?
133 IInterface::asBinder(TClientBase::getRemoteCallback()).get() : NULL),
134 TClientBase::mClientPid);
135 result.append(" State: ");
136
137 write(fd, result.string(), result.size());
138 // TODO: print dynamic/request section from most recent requests
139
140 return dumpDevice(fd, args);
141 }
142
143 template <typename TClientBase>
dumpDevice(int fd,const Vector<String16> & args)144 status_t Camera2ClientBase<TClientBase>::dumpDevice(
145 int fd,
146 const Vector<String16>& args) {
147 String8 result;
148
149 result = " Device dump:\n";
150 write(fd, result.string(), result.size());
151
152 if (!mDevice.get()) {
153 result = " *** Device is detached\n";
154 write(fd, result.string(), result.size());
155 return NO_ERROR;
156 }
157
158 status_t res = mDevice->dump(fd, args);
159 if (res != OK) {
160 result = String8::format(" Error dumping device: %s (%d)",
161 strerror(-res), res);
162 write(fd, result.string(), result.size());
163 }
164
165 return NO_ERROR;
166 }
167
168 // ICameraClient2BaseUser interface
169
170
171 template <typename TClientBase>
disconnect()172 void Camera2ClientBase<TClientBase>::disconnect() {
173 ATRACE_CALL();
174 Mutex::Autolock icl(mBinderSerializationLock);
175
176 // Allow both client and the media server to disconnect at all times
177 int callingPid = getCallingPid();
178 if (callingPid != TClientBase::mClientPid &&
179 callingPid != TClientBase::mServicePid) return;
180
181 ALOGV("Camera %d: Shutting down", TClientBase::mCameraId);
182
183 detachDevice();
184
185 CameraService::BasicClient::disconnect();
186
187 ALOGV("Camera %d: Shut down complete complete", TClientBase::mCameraId);
188 }
189
190 template <typename TClientBase>
detachDevice()191 void Camera2ClientBase<TClientBase>::detachDevice() {
192 if (mDevice == 0) return;
193 mDevice->disconnect();
194
195 mDevice.clear();
196
197 ALOGV("Camera %d: Detach complete", TClientBase::mCameraId);
198 }
199
200 template <typename TClientBase>
connect(const sp<TCamCallbacks> & client)201 status_t Camera2ClientBase<TClientBase>::connect(
202 const sp<TCamCallbacks>& client) {
203 ATRACE_CALL();
204 ALOGV("%s: E", __FUNCTION__);
205 Mutex::Autolock icl(mBinderSerializationLock);
206
207 if (TClientBase::mClientPid != 0 &&
208 getCallingPid() != TClientBase::mClientPid) {
209
210 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
211 "current locked to pid %d",
212 __FUNCTION__,
213 TClientBase::mCameraId,
214 getCallingPid(),
215 TClientBase::mClientPid);
216 return BAD_VALUE;
217 }
218
219 TClientBase::mClientPid = getCallingPid();
220
221 TClientBase::mRemoteCallback = client;
222 mSharedCameraCallbacks = client;
223
224 return OK;
225 }
226
227 /** Device-related methods */
228
229 template <typename TClientBase>
notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,const CaptureResultExtras & resultExtras)230 void Camera2ClientBase<TClientBase>::notifyError(
231 ICameraDeviceCallbacks::CameraErrorCode errorCode,
232 const CaptureResultExtras& resultExtras) {
233 ALOGE("Error condition %d reported by HAL, requestId %" PRId32, errorCode,
234 resultExtras.requestId);
235 }
236
237 template <typename TClientBase>
notifyIdle()238 void Camera2ClientBase<TClientBase>::notifyIdle() {
239 if (mDeviceActive) {
240 getCameraService()->updateProxyDeviceState(
241 ICameraServiceProxy::CAMERA_STATE_IDLE,
242 String8::format("%d", TClientBase::mCameraId));
243 }
244 mDeviceActive = false;
245
246 ALOGV("Camera device is now idle");
247 }
248
249 template <typename TClientBase>
notifyShutter(const CaptureResultExtras & resultExtras,nsecs_t timestamp)250 void Camera2ClientBase<TClientBase>::notifyShutter(const CaptureResultExtras& resultExtras,
251 nsecs_t timestamp) {
252 (void)resultExtras;
253 (void)timestamp;
254
255 if (!mDeviceActive) {
256 getCameraService()->updateProxyDeviceState(
257 ICameraServiceProxy::CAMERA_STATE_ACTIVE,
258 String8::format("%d", TClientBase::mCameraId));
259 }
260 mDeviceActive = true;
261
262 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
263 __FUNCTION__, resultExtras.requestId, timestamp);
264 }
265
266 template <typename TClientBase>
notifyAutoFocus(uint8_t newState,int triggerId)267 void Camera2ClientBase<TClientBase>::notifyAutoFocus(uint8_t newState,
268 int triggerId) {
269 (void)newState;
270 (void)triggerId;
271
272 ALOGV("%s: Autofocus state now %d, last trigger %d",
273 __FUNCTION__, newState, triggerId);
274
275 }
276
277 template <typename TClientBase>
notifyAutoExposure(uint8_t newState,int triggerId)278 void Camera2ClientBase<TClientBase>::notifyAutoExposure(uint8_t newState,
279 int triggerId) {
280 (void)newState;
281 (void)triggerId;
282
283 ALOGV("%s: Autoexposure state now %d, last trigger %d",
284 __FUNCTION__, newState, triggerId);
285 }
286
287 template <typename TClientBase>
notifyAutoWhitebalance(uint8_t newState,int triggerId)288 void Camera2ClientBase<TClientBase>::notifyAutoWhitebalance(uint8_t newState,
289 int triggerId) {
290 (void)newState;
291 (void)triggerId;
292
293 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
294 __FUNCTION__, newState, triggerId);
295 }
296
297 template <typename TClientBase>
notifyPrepared(int streamId)298 void Camera2ClientBase<TClientBase>::notifyPrepared(int streamId) {
299 (void)streamId;
300
301 ALOGV("%s: Stream %d now prepared",
302 __FUNCTION__, streamId);
303 }
304
305 template <typename TClientBase>
getCameraId() const306 int Camera2ClientBase<TClientBase>::getCameraId() const {
307 return TClientBase::mCameraId;
308 }
309
310 template <typename TClientBase>
getCameraDeviceVersion() const311 int Camera2ClientBase<TClientBase>::getCameraDeviceVersion() const {
312 return mDeviceVersion;
313 }
314
315 template <typename TClientBase>
getCameraDevice()316 const sp<CameraDeviceBase>& Camera2ClientBase<TClientBase>::getCameraDevice() {
317 return mDevice;
318 }
319
320 template <typename TClientBase>
getCameraService()321 const sp<CameraService>& Camera2ClientBase<TClientBase>::getCameraService() {
322 return TClientBase::mCameraService;
323 }
324
325 template <typename TClientBase>
Lock(SharedCameraCallbacks & client)326 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::Lock(
327 SharedCameraCallbacks &client) :
328
329 mRemoteCallback(client.mRemoteCallback),
330 mSharedClient(client) {
331
332 mSharedClient.mRemoteCallbackLock.lock();
333 }
334
335 template <typename TClientBase>
~Lock()336 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::~Lock() {
337 mSharedClient.mRemoteCallbackLock.unlock();
338 }
339
340 template <typename TClientBase>
SharedCameraCallbacks(const sp<TCamCallbacks> & client)341 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::SharedCameraCallbacks(
342 const sp<TCamCallbacks>&client) :
343
344 mRemoteCallback(client) {
345 }
346
347 template <typename TClientBase>
348 typename Camera2ClientBase<TClientBase>::SharedCameraCallbacks&
operator =(const sp<TCamCallbacks> & client)349 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::operator=(
350 const sp<TCamCallbacks>&client) {
351
352 Mutex::Autolock l(mRemoteCallbackLock);
353 mRemoteCallback = client;
354 return *this;
355 }
356
357 template <typename TClientBase>
clear()358 void Camera2ClientBase<TClientBase>::SharedCameraCallbacks::clear() {
359 Mutex::Autolock l(mRemoteCallbackLock);
360 mRemoteCallback.clear();
361 }
362
363 template class Camera2ClientBase<CameraService::Client>;
364 template class Camera2ClientBase<CameraDeviceClientBase>;
365
366 } // namespace android
367