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 <android/hardware/ICameraService.h>
31 #include <camera/CameraSessionStats.h>
32 #include <camera/StringUtils.h>
33 #include <com_android_window_flags.h>
34 #include <com_android_internal_camera_flags.h>
35
36 #include "common/Camera2ClientBase.h"
37
38 #include "api2/CameraDeviceClient.h"
39
40 #include "device3/Camera3Device.h"
41 #include "device3/aidl/AidlCamera3Device.h"
42 #include "device3/hidl/HidlCamera3Device.h"
43 #include "device3/aidl/AidlCamera3SharedDevice.h"
44
45 namespace android {
46
47 using namespace camera2;
48
49 namespace wm_flags = com::android::window::flags;
50 namespace flags = com::android::internal::camera::flags;
51
52 // Interface used by CameraService
53
54 template <typename TClientBase>
Camera2ClientBase(const sp<CameraService> & cameraService,const sp<TCamCallbacks> & remoteCallback,std::shared_ptr<CameraServiceProxyWrapper> cameraServiceProxyWrapper,std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,const AttributionSourceState & clientAttribution,int callingPid,bool systemNativeClient,const std::string & cameraId,int api1CameraId,int cameraFacing,int sensorOrientation,int servicePid,bool overrideForPerfClass,int rotationOverride,bool sharedMode,bool legacyClient)55 Camera2ClientBase<TClientBase>::Camera2ClientBase(
56 const sp<CameraService>& cameraService, const sp<TCamCallbacks>& remoteCallback,
57 std::shared_ptr<CameraServiceProxyWrapper> cameraServiceProxyWrapper,
58 std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,
59 const AttributionSourceState& clientAttribution, int callingPid, bool systemNativeClient,
60 const std::string& cameraId, int api1CameraId, int cameraFacing, int sensorOrientation,
61 int servicePid, bool overrideForPerfClass, int rotationOverride, bool sharedMode,
62 bool legacyClient)
63 : TClientBase(cameraService, remoteCallback, attributionAndPermissionUtils, clientAttribution,
64 callingPid, systemNativeClient, cameraId, api1CameraId, cameraFacing,
65 sensorOrientation, servicePid, rotationOverride, sharedMode),
66 mSharedCameraCallbacks(remoteCallback),
67 mCameraServiceProxyWrapper(cameraServiceProxyWrapper),
68 mDeviceActive(false),
69 mApi1CameraId(api1CameraId) {
70 ALOGI("Camera %s: Opened. Client: %s (PID %d, UID %d)", cameraId.c_str(),
71 TClientBase::getPackageName().c_str(), TClientBase::mCallingPid,
72 TClientBase::getClientUid());
73
74 mInitialClientPid = TClientBase::mCallingPid;
75 mOverrideForPerfClass = overrideForPerfClass;
76 mLegacyClient = legacyClient;
77 }
78
79 template <typename TClientBase>
checkPid(const char * checkLocation) const80 status_t Camera2ClientBase<TClientBase>::checkPid(const char* checkLocation)
81 const {
82
83 int callingPid = TClientBase::getCallingPid();
84 if (callingPid == TClientBase::mCallingPid) return NO_ERROR;
85
86 ALOGE("%s: attempt to use a locked camera from a different process"
87 " (old pid %d, new pid %d)", checkLocation, TClientBase::mCallingPid, callingPid);
88 return PERMISSION_DENIED;
89 }
90
91 template <typename TClientBase>
initialize(sp<CameraProviderManager> manager,const std::string & monitorTags)92 status_t Camera2ClientBase<TClientBase>::initialize(sp<CameraProviderManager> manager,
93 const std::string& monitorTags) {
94 return initializeImpl(manager, monitorTags);
95 }
96
97 template <typename TClientBase>
98 template <typename TProviderPtr>
initializeImpl(TProviderPtr providerPtr,const std::string & monitorTags)99 status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr,
100 const std::string& monitorTags) {
101 ATRACE_CALL();
102 ALOGV("%s: Initializing client for camera %s", __FUNCTION__,
103 TClientBase::mCameraIdStr.c_str());
104 status_t res;
105
106 IPCTransport providerTransport = IPCTransport::INVALID;
107 res = providerPtr->getCameraIdIPCTransport(TClientBase::mCameraIdStr,
108 &providerTransport);
109 if (res != OK) {
110 return res;
111 }
112 switch (providerTransport) {
113 case IPCTransport::HIDL:
114 mDevice =
115 new HidlCamera3Device(mCameraServiceProxyWrapper,
116 TClientBase::mAttributionAndPermissionUtils,
117 TClientBase::mCameraIdStr, mOverrideForPerfClass,
118 TClientBase::mRotationOverride, mLegacyClient);
119 break;
120 case IPCTransport::AIDL:
121 if (flags::camera_multi_client() && TClientBase::mSharedMode) {
122 mDevice = AidlCamera3SharedDevice::getInstance(mCameraServiceProxyWrapper,
123 TClientBase::mAttributionAndPermissionUtils,
124 TClientBase::mCameraIdStr, mOverrideForPerfClass,
125 TClientBase::mRotationOverride, mLegacyClient);
126 } else {
127 mDevice =
128 new AidlCamera3Device(mCameraServiceProxyWrapper,
129 TClientBase::mAttributionAndPermissionUtils,
130 TClientBase::mCameraIdStr, mOverrideForPerfClass,
131 TClientBase::mRotationOverride, mLegacyClient);
132 }
133 break;
134 default:
135 ALOGE("%s Invalid transport for camera id %s", __FUNCTION__,
136 TClientBase::mCameraIdStr.c_str());
137 return NO_INIT;
138 }
139 if (mDevice == NULL) {
140 ALOGE("%s: Camera %s: No device connected",
141 __FUNCTION__, TClientBase::mCameraIdStr.c_str());
142 return NO_INIT;
143 }
144
145 // Notify camera opening (check op if check_full_attribution_source_chain flag is off).
146 res = TClientBase::notifyCameraOpening();
147 if (res != OK) {
148 TClientBase::notifyCameraClosing();
149 return res;
150 }
151
152 res = mDevice->initialize(providerPtr, monitorTags);
153 if (res != OK) {
154 ALOGE("%s: Camera %s: unable to initialize device: %s (%d)",
155 __FUNCTION__, TClientBase::mCameraIdStr.c_str(), strerror(-res), res);
156 TClientBase::notifyCameraClosing();
157 return res;
158 }
159
160 wp<NotificationListener> weakThis(this);
161 res = mDevice->setNotifyCallback(weakThis);
162 if (res != OK) {
163 ALOGE("%s: Camera %s: Unable to set notify callback: %s (%d)",
164 __FUNCTION__, TClientBase::mCameraIdStr.c_str(), strerror(-res), res);
165 return res;
166 }
167
168 return OK;
169 }
170
171 template <typename TClientBase>
~Camera2ClientBase()172 Camera2ClientBase<TClientBase>::~Camera2ClientBase() {
173 ATRACE_CALL();
174
175 if (!flags::camera_multi_client() || !TClientBase::mDisconnected) {
176 TClientBase::mDestructionStarted = true;
177 disconnect();
178 }
179
180 ALOGI("%s: Client object's dtor for Camera Id %s completed. Client was: %s (PID %d, UID %u)",
181 __FUNCTION__, TClientBase::mCameraIdStr.c_str(), TClientBase::getPackageName().c_str(),
182 mInitialClientPid, TClientBase::getClientUid());
183 }
184
185 template <typename TClientBase>
dumpClient(int fd,const Vector<String16> & args)186 status_t Camera2ClientBase<TClientBase>::dumpClient(int fd,
187 const Vector<String16>& args) {
188 std::string result;
189 result += fmt::sprintf("Camera2ClientBase[%s] (%p) PID: %d, dump:\n",
190 TClientBase::mCameraIdStr.c_str(),
191 (TClientBase::getRemoteCallback() != NULL ?
192 (void *)IInterface::asBinder(TClientBase::getRemoteCallback()).get() : NULL),
193 TClientBase::mCallingPid);
194 result += " State: ";
195
196 write(fd, result.c_str(), result.size());
197 // TODO: print dynamic/request section from most recent requests
198
199 return dumpDevice(fd, args);
200 }
201
202 template <typename TClientBase>
startWatchingTags(const std::string & tags,int out)203 status_t Camera2ClientBase<TClientBase>::startWatchingTags(const std::string &tags, int out) {
204 sp<CameraDeviceBase> device = mDevice;
205 if (!device) {
206 dprintf(out, " Device is detached");
207 return OK;
208 }
209
210 return device->startWatchingTags(tags);
211 }
212
213 template <typename TClientBase>
stopWatchingTags(int out)214 status_t Camera2ClientBase<TClientBase>::stopWatchingTags(int out) {
215 sp<CameraDeviceBase> device = mDevice;
216 if (!device) {
217 dprintf(out, " Device is detached");
218 return OK;
219 }
220
221 return device->stopWatchingTags();
222 }
223
224 template <typename TClientBase>
dumpWatchedEventsToVector(std::vector<std::string> & out)225 status_t Camera2ClientBase<TClientBase>::dumpWatchedEventsToVector(std::vector<std::string> &out) {
226 sp<CameraDeviceBase> device = mDevice;
227 if (!device) {
228 // Nothing to dump if the device is detached
229 return OK;
230 }
231 return device->dumpWatchedEventsToVector(out);
232 }
233
234 template <typename TClientBase>
dumpDevice(int fd,const Vector<String16> & args)235 status_t Camera2ClientBase<TClientBase>::dumpDevice(
236 int fd,
237 const Vector<String16>& args) {
238 std::string result;
239
240 result = " Device dump:\n";
241 write(fd, result.c_str(), result.size());
242
243 sp<CameraDeviceBase> device = mDevice;
244 if (!device.get()) {
245 result = " *** Device is detached\n";
246 write(fd, result.c_str(), result.size());
247 return NO_ERROR;
248 }
249
250 status_t res = device->dump(fd, args);
251 if (res != OK) {
252 result = fmt::sprintf(" Error dumping device: %s (%d)",
253 strerror(-res), res);
254 write(fd, result.c_str(), result.size());
255 }
256
257 return NO_ERROR;
258 }
259
260 // ICameraClient2BaseUser interface
261
262 template <typename TClientBase>
disconnect()263 binder::Status Camera2ClientBase<TClientBase>::disconnect() {
264
265 if (!flags::camera_multi_client() || !TClientBase::mDisconnected) {
266 return disconnectImpl();
267 }
268 return binder::Status::ok();
269 }
270
271 template <typename TClientBase>
disconnectImpl()272 binder::Status Camera2ClientBase<TClientBase>::disconnectImpl() {
273 ATRACE_CALL();
274 ALOGD("Camera %s: start to disconnect", TClientBase::mCameraIdStr.c_str());
275 Mutex::Autolock icl(mBinderSerializationLock);
276
277 ALOGD("Camera %s: serializationLock acquired", TClientBase::mCameraIdStr.c_str());
278 binder::Status res = binder::Status::ok();
279 // Allow both client and the media server to disconnect at all times
280 int callingPid = TClientBase::getCallingPid();
281 if (callingPid != TClientBase::mCallingPid &&
282 callingPid != TClientBase::mServicePid) return res;
283
284 ALOGD("Camera %s: Shutting down", TClientBase::mCameraIdStr.c_str());
285
286 // Before detaching the device, cache the info from current open session.
287 // The disconnected check avoids duplication of info and also prevents
288 // deadlock while acquiring service lock in cacheDump.
289 if (!TClientBase::mDisconnected) {
290 ALOGD("Camera %s: start to cacheDump", TClientBase::mCameraIdStr.c_str());
291 Camera2ClientBase::getCameraService()->cacheDump();
292 }
293
294 detachDevice();
295
296 CameraService::BasicClient::disconnect();
297
298 ALOGV("Camera %s: Shut down complete", TClientBase::mCameraIdStr.c_str());
299
300 return res;
301 }
302
303 template <typename TClientBase>
detachDevice()304 void Camera2ClientBase<TClientBase>::detachDevice() {
305 if (mDevice == 0) return;
306 if (flags::camera_multi_client() && TClientBase::mSharedMode) {
307 mDevice->disconnectClient(TClientBase::getClientUid());
308 } else {
309 mDevice->disconnect();
310 }
311
312 ALOGV("Camera %s: Detach complete", TClientBase::mCameraIdStr.c_str());
313 }
314
315 template <typename TClientBase>
connect(const sp<TCamCallbacks> & client)316 status_t Camera2ClientBase<TClientBase>::connect(
317 const sp<TCamCallbacks>& client) {
318 ATRACE_CALL();
319 ALOGV("%s: E", __FUNCTION__);
320 Mutex::Autolock icl(mBinderSerializationLock);
321
322 if (TClientBase::mCallingPid != 0 &&
323 TClientBase::getCallingPid() != TClientBase::mCallingPid) {
324
325 ALOGE("%s: Camera %s: Connection attempt from pid %d; "
326 "current locked to pid %d",
327 __FUNCTION__,
328 TClientBase::mCameraIdStr.c_str(),
329 TClientBase::getCallingPid(),
330 TClientBase::mCallingPid);
331 return BAD_VALUE;
332 }
333
334 TClientBase::mCallingPid = TClientBase::getCallingPid();
335
336 TClientBase::mRemoteCallback = client;
337 mSharedCameraCallbacks = client;
338
339 return OK;
340 }
341
342 /** Device-related methods */
343
344 template <typename TClientBase>
notifyError(int32_t errorCode,const CaptureResultExtras & resultExtras)345 void Camera2ClientBase<TClientBase>::notifyError(
346 int32_t errorCode,
347 const CaptureResultExtras& resultExtras) {
348 ALOGE("Error condition %d reported by HAL, requestId %" PRId32, errorCode,
349 resultExtras.requestId);
350 }
351
352 template <typename TClientBase>
notifyClientSharedAccessPriorityChanged(bool primaryClient)353 void Camera2ClientBase<TClientBase>::notifyClientSharedAccessPriorityChanged(bool primaryClient) {
354 ALOGV("%s Camera %s access priorities changed for client %d primaryClient=%d", __FUNCTION__,
355 TClientBase::mCameraIdStr.c_str(), TClientBase::getClientUid(), primaryClient);
356 }
357
358 template <typename TClientBase>
notifyPhysicalCameraChange(const std::string & physicalId)359 void Camera2ClientBase<TClientBase>::notifyPhysicalCameraChange(const std::string &physicalId) {
360 using android::hardware::ICameraService;
361 // We're only interested in this notification if rotationOverride is turned on.
362 if (TClientBase::mRotationOverride == ICameraService::ROTATION_OVERRIDE_NONE) {
363 return;
364 }
365
366 auto physicalCameraMetadata = mDevice->infoPhysical(physicalId);
367 auto orientationEntry = physicalCameraMetadata.find(ANDROID_SENSOR_ORIENTATION);
368
369 if (orientationEntry.count == 1) {
370 int orientation = orientationEntry.data.i32[0];
371 int rotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
372 bool landscapeSensor = (orientation == 0 || orientation == 180);
373 if (((TClientBase::mRotationOverride ==
374 ICameraService::ROTATION_OVERRIDE_OVERRIDE_TO_PORTRAIT) && landscapeSensor) ||
375 ((wm_flags::enable_camera_compat_for_desktop_windowing() &&
376 TClientBase::mRotationOverride ==
377 ICameraService::ROTATION_OVERRIDE_ROTATION_ONLY)
378 && !landscapeSensor)) {
379 rotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_90;
380 }
381
382 static_cast<TClientBase *>(this)->setRotateAndCropOverride(rotateAndCropMode,
383 /*fromHal*/ true);
384 }
385 }
386
387 template <typename TClientBase>
notifyActive(float maxPreviewFps)388 status_t Camera2ClientBase<TClientBase>::notifyActive(float maxPreviewFps) {
389 if (!mDeviceActive) {
390 status_t res = TClientBase::startCameraStreamingOps();
391 if (res != OK) {
392 ALOGE("%s: Camera %s: Error starting camera streaming ops: %d", __FUNCTION__,
393 TClientBase::mCameraIdStr.c_str(), res);
394 return res;
395 }
396 mCameraServiceProxyWrapper->logActive(TClientBase::mCameraIdStr, maxPreviewFps);
397 }
398 mDeviceActive = true;
399
400 ALOGV("Camera device is now active");
401 return OK;
402 }
403
404 template <typename TClientBase>
notifyIdleWithUserTag(int64_t requestCount,int64_t resultErrorCount,bool deviceError,std::pair<int32_t,int32_t> mostRequestedFpsRange,const std::vector<hardware::CameraStreamStats> & streamStats,const std::string & userTag,int videoStabilizationMode,bool usedUltraWide,bool usedZoomOverride)405 void Camera2ClientBase<TClientBase>::notifyIdleWithUserTag(
406 int64_t requestCount, int64_t resultErrorCount, bool deviceError,
407 std::pair<int32_t, int32_t> mostRequestedFpsRange,
408 const std::vector<hardware::CameraStreamStats>& streamStats,
409 const std::string& userTag, int videoStabilizationMode, bool usedUltraWide,
410 bool usedZoomOverride) {
411 if (mDeviceActive) {
412 status_t res = TClientBase::finishCameraStreamingOps();
413 if (res != OK) {
414 ALOGE("%s: Camera %s: Error finishing streaming ops: %d", __FUNCTION__,
415 TClientBase::mCameraIdStr.c_str(), res);
416 }
417 mCameraServiceProxyWrapper->logIdle(TClientBase::mCameraIdStr,
418 requestCount, resultErrorCount, deviceError, userTag, videoStabilizationMode,
419 usedUltraWide, usedZoomOverride, mostRequestedFpsRange, streamStats);
420 }
421 mDeviceActive = false;
422
423 ALOGV("Camera device is now idle");
424 }
425
426 template <typename TClientBase>
notifyShutter(const CaptureResultExtras & resultExtras,nsecs_t timestamp)427 void Camera2ClientBase<TClientBase>::notifyShutter(
428 [[maybe_unused]] const CaptureResultExtras& resultExtras,
429 [[maybe_unused]] nsecs_t timestamp) {
430 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
431 __FUNCTION__, resultExtras.requestId, timestamp);
432 }
433
434 template <typename TClientBase>
notifyAutoFocus(uint8_t newState,int triggerId)435 void Camera2ClientBase<TClientBase>::notifyAutoFocus([[maybe_unused]] uint8_t newState,
436 [[maybe_unused]] int triggerId) {
437 ALOGV("%s: Autofocus state now %d, last trigger %d",
438 __FUNCTION__, newState, triggerId);
439
440 }
441
442 template <typename TClientBase>
notifyAutoExposure(uint8_t newState,int triggerId)443 void Camera2ClientBase<TClientBase>::notifyAutoExposure([[maybe_unused]] uint8_t newState,
444 [[maybe_unused]] int triggerId) {
445 ALOGV("%s: Autoexposure state now %d, last trigger %d",
446 __FUNCTION__, newState, triggerId);
447 }
448
449 template <typename TClientBase>
notifyAutoWhitebalance(uint8_t newState,int triggerId)450 void Camera2ClientBase<TClientBase>::notifyAutoWhitebalance(
451 [[maybe_unused]] uint8_t newState,
452 [[maybe_unused]] int triggerId) {
453 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
454 __FUNCTION__, newState, triggerId);
455 }
456
457 template <typename TClientBase>
notifyPrepared(int streamId)458 void Camera2ClientBase<TClientBase>::notifyPrepared([[maybe_unused]] int streamId) {
459 ALOGV("%s: Stream %d now prepared",
460 __FUNCTION__, streamId);
461 }
462
463 template <typename TClientBase>
notifyRequestQueueEmpty()464 void Camera2ClientBase<TClientBase>::notifyRequestQueueEmpty() {
465
466 ALOGV("%s: Request queue now empty", __FUNCTION__);
467 }
468
469 template <typename TClientBase>
notifyRepeatingRequestError(long lastFrameNumber)470 void Camera2ClientBase<TClientBase>::notifyRepeatingRequestError(
471 [[maybe_unused]] long lastFrameNumber) {
472 ALOGV("%s: Repeating request was stopped. Last frame number is %ld",
473 __FUNCTION__, lastFrameNumber);
474 }
475
476 template <typename TClientBase>
getCameraId() const477 int Camera2ClientBase<TClientBase>::getCameraId() const {
478 return mApi1CameraId;
479 }
480
481 template <typename TClientBase>
getCameraDevice()482 const sp<CameraDeviceBase>& Camera2ClientBase<TClientBase>::getCameraDevice() {
483 return mDevice;
484 }
485
486 template <typename TClientBase>
getCameraService()487 const sp<CameraService>& Camera2ClientBase<TClientBase>::getCameraService() {
488 return TClientBase::sCameraService;
489 }
490
491 template <typename TClientBase>
Lock(SharedCameraCallbacks & client)492 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::Lock(
493 SharedCameraCallbacks &client) :
494
495 mRemoteCallback(client.mRemoteCallback),
496 mSharedClient(client) {
497
498 mSharedClient.mRemoteCallbackLock.lock();
499 }
500
501 template <typename TClientBase>
~Lock()502 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::~Lock() {
503 mSharedClient.mRemoteCallbackLock.unlock();
504 }
505
506 template <typename TClientBase>
SharedCameraCallbacks(const sp<TCamCallbacks> & client)507 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::SharedCameraCallbacks(
508 const sp<TCamCallbacks>&client) :
509
510 mRemoteCallback(client) {
511 }
512
513 template <typename TClientBase>
514 typename Camera2ClientBase<TClientBase>::SharedCameraCallbacks&
operator =(const sp<TCamCallbacks> & client)515 Camera2ClientBase<TClientBase>::SharedCameraCallbacks::operator=(
516 const sp<TCamCallbacks>&client) {
517
518 Mutex::Autolock l(mRemoteCallbackLock);
519 mRemoteCallback = client;
520 return *this;
521 }
522
523 template <typename TClientBase>
clear()524 void Camera2ClientBase<TClientBase>::SharedCameraCallbacks::clear() {
525 Mutex::Autolock l(mRemoteCallbackLock);
526 mRemoteCallback.clear();
527 }
528
529 template <typename TClientBase>
injectCamera(const std::string & injectedCamId,sp<CameraProviderManager> manager)530 status_t Camera2ClientBase<TClientBase>::injectCamera(const std::string& injectedCamId,
531 sp<CameraProviderManager> manager) {
532 return mDevice->injectCamera(injectedCamId, manager);
533 }
534
535 template <typename TClientBase>
stopInjection()536 status_t Camera2ClientBase<TClientBase>::stopInjection() {
537 return mDevice->stopInjection();
538 }
539
540 template <typename TClientBase>
injectSessionParams(const CameraMetadata & sessionParams)541 status_t Camera2ClientBase<TClientBase>::injectSessionParams(
542 const CameraMetadata& sessionParams) {
543 return mDevice->injectSessionParams(sessionParams);
544 }
545
546 template class Camera2ClientBase<CameraService::Client>;
547 template class Camera2ClientBase<CameraDeviceClientBase>;
548
549 } // namespace android
550