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 {
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 
68 template <typename TClientBase>
checkPid(const char * checkLocation) const69 status_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 
80 template <typename TClientBase>
initialize(CameraModule * module)81 status_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 
111 template <typename TClientBase>
~Camera2ClientBase()112 Camera2ClientBase<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 
125 template <typename TClientBase>
dump(int fd,const Vector<String16> & args)126 status_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 
142 template <typename TClientBase>
dumpDevice(int fd,const Vector<String16> & args)143 status_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 
170 template <typename TClientBase>
disconnect()171 void 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 
189 template <typename TClientBase>
detachDevice()190 void 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 
199 template <typename TClientBase>
connect(const sp<TCamCallbacks> & client)200 status_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 
228 template <typename TClientBase>
notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,const CaptureResultExtras & resultExtras)229 void 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 
236 template <typename TClientBase>
notifyIdle()237 void Camera2ClientBase<TClientBase>::notifyIdle() {
238     ALOGV("Camera device is now idle");
239 }
240 
241 template <typename TClientBase>
notifyShutter(const CaptureResultExtras & resultExtras,nsecs_t timestamp)242 void 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 
251 template <typename TClientBase>
notifyAutoFocus(uint8_t newState,int triggerId)252 void 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 
262 template <typename TClientBase>
notifyAutoExposure(uint8_t newState,int triggerId)263 void 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 
272 template <typename TClientBase>
notifyAutoWhitebalance(uint8_t newState,int triggerId)273 void 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 
282 template <typename TClientBase>
notifyPrepared(int streamId)283 void Camera2ClientBase<TClientBase>::notifyPrepared(int streamId) {
284     (void)streamId;
285 
286     ALOGV("%s: Stream %d now prepared",
287             __FUNCTION__, streamId);
288 }
289 
290 template <typename TClientBase>
getCameraId() const291 int Camera2ClientBase<TClientBase>::getCameraId() const {
292     return TClientBase::mCameraId;
293 }
294 
295 template <typename TClientBase>
getCameraDeviceVersion() const296 int Camera2ClientBase<TClientBase>::getCameraDeviceVersion() const {
297     return mDeviceVersion;
298 }
299 
300 template <typename TClientBase>
getCameraDevice()301 const sp<CameraDeviceBase>& Camera2ClientBase<TClientBase>::getCameraDevice() {
302     return mDevice;
303 }
304 
305 template <typename TClientBase>
getCameraService()306 const sp<CameraService>& Camera2ClientBase<TClientBase>::getCameraService() {
307     return TClientBase::mCameraService;
308 }
309 
310 template <typename TClientBase>
Lock(SharedCameraCallbacks & client)311 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::Lock(
312         SharedCameraCallbacks &client) :
313 
314         mRemoteCallback(client.mRemoteCallback),
315         mSharedClient(client) {
316 
317     mSharedClient.mRemoteCallbackLock.lock();
318 }
319 
320 template <typename TClientBase>
~Lock()321 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::~Lock() {
322     mSharedClient.mRemoteCallbackLock.unlock();
323 }
324 
325 template <typename TClientBase>
SharedCameraCallbacks(const sp<TCamCallbacks> & client)326 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::SharedCameraCallbacks(
327         const sp<TCamCallbacks>&client) :
328 
329         mRemoteCallback(client) {
330 }
331 
332 template <typename TClientBase>
333 typename Camera2ClientBase<TClientBase>::SharedCameraCallbacks&
operator =(const sp<TCamCallbacks> & client)334 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::operator=(
335         const sp<TCamCallbacks>&client) {
336 
337     Mutex::Autolock l(mRemoteCallbackLock);
338     mRemoteCallback = client;
339     return *this;
340 }
341 
342 template <typename TClientBase>
clear()343 void Camera2ClientBase<TClientBase>::SharedCameraCallbacks::clear() {
344     Mutex::Autolock l(mRemoteCallbackLock);
345     mRemoteCallback.clear();
346 }
347 
348 template class Camera2ClientBase<CameraService::Client>;
349 template class Camera2ClientBase<CameraDeviceClientBase>;
350 
351 } // namespace android
352