blob: 92309c381714962b8c0557f117d436d0c843acf6 [file] [log] [blame]
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001/*
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
Colin Crosse5729fa2014-03-21 15:04:25 -070021#include <inttypes.h>
22
Igor Murashkin44cfcf02013-03-01 16:22:28 -080023#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>
Igor Murashkin44cfcf02013-03-01 16:22:28 -080029
Shuzhen Wang316781a2020-08-18 18:11:01 -070030#include <camera/CameraSessionStats.h>
Austin Borger1c1bee02023-06-01 16:51:35 -070031#include <camera/StringUtils.h>
Shuzhen Wang316781a2020-08-18 18:11:01 -070032
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070033#include "common/Camera2ClientBase.h"
Igor Murashkine7ee7632013-06-11 18:10:18 -070034
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070035#include "api2/CameraDeviceClient.h"
36
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -080037#include "device3/Camera3Device.h"
Jayant Chowdhary35642f22022-01-08 00:39:39 +000038#include "device3/aidl/AidlCamera3Device.h"
Jayant Chowdhary22441f32021-12-26 18:35:41 -080039#include "device3/hidl/HidlCamera3Device.h"
Igor Murashkin44cfcf02013-03-01 16:22:28 -080040
41namespace android {
Jayant Chowdhary620763f2022-05-27 05:37:14 +000042
Igor Murashkin44cfcf02013-03-01 16:22:28 -080043using namespace camera2;
44
Igor Murashkin44cfcf02013-03-01 16:22:28 -080045// Interface used by CameraService
46
47template <typename TClientBase>
48Camera2ClientBase<TClientBase>::Camera2ClientBase(
49 const sp<CameraService>& cameraService,
50 const sp<TCamCallbacks>& remoteCallback,
Austin Borger74fca042022-05-23 12:41:21 -070051 std::shared_ptr<CameraServiceProxyWrapper> cameraServiceProxyWrapper,
Austin Borger249e6592024-03-10 22:28:11 -070052 std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,
Austin Borger1c1bee02023-06-01 16:51:35 -070053 const std::string& clientPackageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -080054 bool systemNativeClient,
Austin Borger1c1bee02023-06-01 16:51:35 -070055 const std::optional<std::string>& clientFeatureId,
56 const std::string& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080057 int api1CameraId,
Igor Murashkin44cfcf02013-03-01 16:22:28 -080058 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -070059 int sensorOrientation,
Igor Murashkin44cfcf02013-03-01 16:22:28 -080060 int clientPid,
61 uid_t clientUid,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070062 int servicePid,
Emilian Peev5104fe92021-10-21 14:27:09 -070063 bool overrideForPerfClass,
Austin Borger18b30a72022-10-27 12:20:29 -070064 bool overrideToPortrait,
Emilian Peev5104fe92021-10-21 14:27:09 -070065 bool legacyClient):
Austin Borger249e6592024-03-10 22:28:11 -070066 TClientBase(cameraService, remoteCallback, attributionAndPermissionUtils, clientPackageName,
67 systemNativeClient, clientFeatureId, cameraId, api1CameraId, cameraFacing,
68 sensorOrientation, clientPid, clientUid, servicePid, overrideToPortrait),
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070069 mSharedCameraCallbacks(remoteCallback),
Austin Borger74fca042022-05-23 12:41:21 -070070 mCameraServiceProxyWrapper(cameraServiceProxyWrapper),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080071 mDeviceActive(false), mApi1CameraId(api1CameraId)
Igor Murashkin44cfcf02013-03-01 16:22:28 -080072{
Austin Borger1c1bee02023-06-01 16:51:35 -070073 ALOGI("Camera %s: Opened. Client: %s (PID %d, UID %d)", cameraId.c_str(),
74 clientPackageName.c_str(), clientPid, clientUid);
Igor Murashkin98e24722013-06-19 19:51:04 -070075
Eino-Ville Talvalab9d2f332014-09-18 17:24:22 -070076 mInitialClientPid = clientPid;
Jayant Chowdhary22441f32021-12-26 18:35:41 -080077 mOverrideForPerfClass = overrideForPerfClass;
78 mLegacyClient = legacyClient;
Igor Murashkin44cfcf02013-03-01 16:22:28 -080079}
80
81template <typename TClientBase>
82status_t Camera2ClientBase<TClientBase>::checkPid(const char* checkLocation)
83 const {
84
Austin Borger22c5c852024-03-08 13:31:36 -080085 int callingPid = TClientBase::getCallingPid();
Igor Murashkin44cfcf02013-03-01 16:22:28 -080086 if (callingPid == TClientBase::mClientPid) return NO_ERROR;
87
88 ALOGE("%s: attempt to use a locked camera from a different process"
89 " (old pid %d, new pid %d)", checkLocation, TClientBase::mClientPid, callingPid);
90 return PERMISSION_DENIED;
91}
92
93template <typename TClientBase>
Emilian Peevbd8c5032018-02-14 23:05:40 +000094status_t Camera2ClientBase<TClientBase>::initialize(sp<CameraProviderManager> manager,
Austin Borger1c1bee02023-06-01 16:51:35 -070095 const std::string& monitorTags) {
Emilian Peevbd8c5032018-02-14 23:05:40 +000096 return initializeImpl(manager, monitorTags);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080097}
98
99template <typename TClientBase>
100template <typename TProviderPtr>
Emilian Peevbd8c5032018-02-14 23:05:40 +0000101status_t Camera2ClientBase<TClientBase>::initializeImpl(TProviderPtr providerPtr,
Austin Borger1c1bee02023-06-01 16:51:35 -0700102 const std::string& monitorTags) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800103 ATRACE_CALL();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800104 ALOGV("%s: Initializing client for camera %s", __FUNCTION__,
Austin Borger1c1bee02023-06-01 16:51:35 -0700105 TClientBase::mCameraIdStr.c_str());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800106 status_t res;
107
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800108 IPCTransport providerTransport = IPCTransport::INVALID;
Austin Borger1c1bee02023-06-01 16:51:35 -0700109 res = providerPtr->getCameraIdIPCTransport(TClientBase::mCameraIdStr,
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800110 &providerTransport);
111 if (res != OK) {
112 return res;
113 }
114 switch (providerTransport) {
115 case IPCTransport::HIDL:
116 mDevice =
Austin Borger74fca042022-05-23 12:41:21 -0700117 new HidlCamera3Device(mCameraServiceProxyWrapper,
Austin Borger22c5c852024-03-08 13:31:36 -0800118 TClientBase::mAttributionAndPermissionUtils,
Austin Borger18b30a72022-10-27 12:20:29 -0700119 TClientBase::mCameraIdStr, mOverrideForPerfClass,
120 TClientBase::mOverrideToPortrait, mLegacyClient);
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800121 break;
122 case IPCTransport::AIDL:
Jayant Chowdhary35642f22022-01-08 00:39:39 +0000123 mDevice =
Austin Borger74fca042022-05-23 12:41:21 -0700124 new AidlCamera3Device(mCameraServiceProxyWrapper,
Austin Borger22c5c852024-03-08 13:31:36 -0800125 TClientBase::mAttributionAndPermissionUtils,
Austin Borger18b30a72022-10-27 12:20:29 -0700126 TClientBase::mCameraIdStr, mOverrideForPerfClass,
127 TClientBase::mOverrideToPortrait, mLegacyClient);
Jayant Chowdhary35642f22022-01-08 00:39:39 +0000128 break;
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800129 default:
130 ALOGE("%s Invalid transport for camera id %s", __FUNCTION__,
Austin Borger1c1bee02023-06-01 16:51:35 -0700131 TClientBase::mCameraIdStr.c_str());
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800132 return NO_INIT;
133 }
Igor Murashkine6800ce2013-03-04 17:25:57 -0800134 if (mDevice == NULL) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800135 ALOGE("%s: Camera %s: No device connected",
Austin Borger1c1bee02023-06-01 16:51:35 -0700136 __FUNCTION__, TClientBase::mCameraIdStr.c_str());
Igor Murashkine6800ce2013-03-04 17:25:57 -0800137 return NO_INIT;
138 }
139
Emilian Peev510546a2024-03-07 01:21:28 +0000140 // Verify ops permissions
141 res = TClientBase::startCameraOps();
142 if (res != OK) {
143 TClientBase::finishCameraOps();
144 return res;
145 }
146
Emilian Peevbd8c5032018-02-14 23:05:40 +0000147 res = mDevice->initialize(providerPtr, monitorTags);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800148 if (res != OK) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800149 ALOGE("%s: Camera %s: unable to initialize device: %s (%d)",
Austin Borger1c1bee02023-06-01 16:51:35 -0700150 __FUNCTION__, TClientBase::mCameraIdStr.c_str(), strerror(-res), res);
Emilian Peevfa17f092022-07-29 13:28:55 -0700151 TClientBase::finishCameraOps();
Emilian Peevfa17f092022-07-29 13:28:55 -0700152 return res;
153 }
154
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800155 wp<NotificationListener> weakThis(this);
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700156 res = mDevice->setNotifyCallback(weakThis);
Austin Borger7b129542022-06-09 13:23:06 -0700157 if (res != OK) {
158 ALOGE("%s: Camera %s: Unable to set notify callback: %s (%d)",
Austin Borger1c1bee02023-06-01 16:51:35 -0700159 __FUNCTION__, TClientBase::mCameraIdStr.c_str(), strerror(-res), res);
Austin Borger7b129542022-06-09 13:23:06 -0700160 return res;
161 }
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800162
163 return OK;
164}
165
166template <typename TClientBase>
167Camera2ClientBase<TClientBase>::~Camera2ClientBase() {
168 ATRACE_CALL();
169
170 TClientBase::mDestructionStarted = true;
171
172 disconnect();
173
Jayant Chowdhary3ab499d2022-06-15 15:43:33 -0700174 ALOGI("%s: Client object's dtor for Camera Id %s completed. Client was: %s (PID %d, UID %u)",
Austin Borger1c1bee02023-06-01 16:51:35 -0700175 __FUNCTION__, TClientBase::mCameraIdStr.c_str(),
176 TClientBase::mClientPackageName.c_str(),
Eino-Ville Talvalab9d2f332014-09-18 17:24:22 -0700177 mInitialClientPid, TClientBase::mClientUid);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800178}
179
180template <typename TClientBase>
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800181status_t Camera2ClientBase<TClientBase>::dumpClient(int fd,
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800182 const Vector<String16>& args) {
Austin Borger1c1bee02023-06-01 16:51:35 -0700183 std::string result;
184 result += fmt::sprintf("Camera2ClientBase[%s] (%p) PID: %d, dump:\n",
185 TClientBase::mCameraIdStr.c_str(),
Eino-Ville Talvalae992e752014-11-07 16:17:48 -0800186 (TClientBase::getRemoteCallback() != NULL ?
Austin Borger1c1bee02023-06-01 16:51:35 -0700187 (void *)IInterface::asBinder(TClientBase::getRemoteCallback()).get() : NULL),
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800188 TClientBase::mClientPid);
Austin Borger1c1bee02023-06-01 16:51:35 -0700189 result += " State: ";
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800190
Austin Borger1c1bee02023-06-01 16:51:35 -0700191 write(fd, result.c_str(), result.size());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800192 // TODO: print dynamic/request section from most recent requests
193
194 return dumpDevice(fd, args);
195}
196
197template <typename TClientBase>
Austin Borger1c1bee02023-06-01 16:51:35 -0700198status_t Camera2ClientBase<TClientBase>::startWatchingTags(const std::string &tags, int out) {
Avichal Rakesh7e53cad2021-10-05 13:46:30 -0700199 sp<CameraDeviceBase> device = mDevice;
200 if (!device) {
201 dprintf(out, " Device is detached");
202 return OK;
203 }
204
205 return device->startWatchingTags(tags);
206}
207
208template <typename TClientBase>
209status_t Camera2ClientBase<TClientBase>::stopWatchingTags(int out) {
210 sp<CameraDeviceBase> device = mDevice;
211 if (!device) {
212 dprintf(out, " Device is detached");
213 return OK;
214 }
215
216 return device->stopWatchingTags();
217}
218
219template <typename TClientBase>
220status_t Camera2ClientBase<TClientBase>::dumpWatchedEventsToVector(std::vector<std::string> &out) {
221 sp<CameraDeviceBase> device = mDevice;
222 if (!device) {
223 // Nothing to dump if the device is detached
224 return OK;
225 }
226 return device->dumpWatchedEventsToVector(out);
227}
228
229template <typename TClientBase>
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800230status_t Camera2ClientBase<TClientBase>::dumpDevice(
231 int fd,
232 const Vector<String16>& args) {
Austin Borger1c1bee02023-06-01 16:51:35 -0700233 std::string result;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800234
235 result = " Device dump:\n";
Austin Borger1c1bee02023-06-01 16:51:35 -0700236 write(fd, result.c_str(), result.size());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800237
Yin-Chia Yehe5138f12017-11-10 14:10:05 -0800238 sp<CameraDeviceBase> device = mDevice;
239 if (!device.get()) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800240 result = " *** Device is detached\n";
Austin Borger1c1bee02023-06-01 16:51:35 -0700241 write(fd, result.c_str(), result.size());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800242 return NO_ERROR;
243 }
244
Yin-Chia Yehe5138f12017-11-10 14:10:05 -0800245 status_t res = device->dump(fd, args);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800246 if (res != OK) {
Austin Borger1c1bee02023-06-01 16:51:35 -0700247 result = fmt::sprintf(" Error dumping device: %s (%d)",
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800248 strerror(-res), res);
Austin Borger1c1bee02023-06-01 16:51:35 -0700249 write(fd, result.c_str(), result.size());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800250 }
251
252 return NO_ERROR;
253}
254
255// ICameraClient2BaseUser interface
256
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800257template <typename TClientBase>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800258binder::Status Camera2ClientBase<TClientBase>::disconnect() {
Ravneet Dhanjalbaa324b2023-10-11 01:19:18 +0000259
Jayant Chowdhary3f20d192022-05-31 17:24:39 +0000260 return disconnectImpl();
Jayant Chowdhary620763f2022-05-27 05:37:14 +0000261}
262
263template <typename TClientBase>
264binder::Status Camera2ClientBase<TClientBase>::disconnectImpl() {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800265 ATRACE_CALL();
Austin Borger1c1bee02023-06-01 16:51:35 -0700266 ALOGD("Camera %s: start to disconnect", TClientBase::mCameraIdStr.c_str());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800267 Mutex::Autolock icl(mBinderSerializationLock);
268
Austin Borger1c1bee02023-06-01 16:51:35 -0700269 ALOGD("Camera %s: serializationLock acquired", TClientBase::mCameraIdStr.c_str());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800270 binder::Status res = binder::Status::ok();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800271 // Allow both client and the media server to disconnect at all times
Austin Borger22c5c852024-03-08 13:31:36 -0800272 int callingPid = TClientBase::getCallingPid();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800273 if (callingPid != TClientBase::mClientPid &&
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800274 callingPid != TClientBase::mServicePid) return res;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800275
Austin Borger1c1bee02023-06-01 16:51:35 -0700276 ALOGD("Camera %s: Shutting down", TClientBase::mCameraIdStr.c_str());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800277
Rucha Katakwardf223072021-06-15 10:21:00 -0700278 // Before detaching the device, cache the info from current open session.
279 // The disconnected check avoids duplication of info and also prevents
280 // deadlock while acquiring service lock in cacheDump.
281 if (!TClientBase::mDisconnected) {
Austin Borger1c1bee02023-06-01 16:51:35 -0700282 ALOGD("Camera %s: start to cacheDump", TClientBase::mCameraIdStr.c_str());
Rucha Katakwardf223072021-06-15 10:21:00 -0700283 Camera2ClientBase::getCameraService()->cacheDump();
284 }
285
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800286 detachDevice();
287
Igor Murashkine6800ce2013-03-04 17:25:57 -0800288 CameraService::BasicClient::disconnect();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800289
Austin Borger1c1bee02023-06-01 16:51:35 -0700290 ALOGV("Camera %s: Shut down complete", TClientBase::mCameraIdStr.c_str());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800291
292 return res;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800293}
294
295template <typename TClientBase>
296void Camera2ClientBase<TClientBase>::detachDevice() {
297 if (mDevice == 0) return;
298 mDevice->disconnect();
299
Austin Borger1c1bee02023-06-01 16:51:35 -0700300 ALOGV("Camera %s: Detach complete", TClientBase::mCameraIdStr.c_str());
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800301}
302
303template <typename TClientBase>
304status_t Camera2ClientBase<TClientBase>::connect(
305 const sp<TCamCallbacks>& client) {
306 ATRACE_CALL();
307 ALOGV("%s: E", __FUNCTION__);
308 Mutex::Autolock icl(mBinderSerializationLock);
309
310 if (TClientBase::mClientPid != 0 &&
Austin Borger22c5c852024-03-08 13:31:36 -0800311 TClientBase::getCallingPid() != TClientBase::mClientPid) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800312
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800313 ALOGE("%s: Camera %s: Connection attempt from pid %d; "
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800314 "current locked to pid %d",
315 __FUNCTION__,
Austin Borger1c1bee02023-06-01 16:51:35 -0700316 TClientBase::mCameraIdStr.c_str(),
Austin Borger22c5c852024-03-08 13:31:36 -0800317 TClientBase::getCallingPid(),
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800318 TClientBase::mClientPid);
319 return BAD_VALUE;
320 }
321
Austin Borger22c5c852024-03-08 13:31:36 -0800322 TClientBase::mClientPid = TClientBase::getCallingPid();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800323
324 TClientBase::mRemoteCallback = client;
325 mSharedCameraCallbacks = client;
326
327 return OK;
328}
329
330/** Device-related methods */
331
332template <typename TClientBase>
Jianing Weicb0652e2014-03-12 18:29:36 -0700333void Camera2ClientBase<TClientBase>::notifyError(
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800334 int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -0700335 const CaptureResultExtras& resultExtras) {
336 ALOGE("Error condition %d reported by HAL, requestId %" PRId32, errorCode,
337 resultExtras.requestId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800338}
339
340template <typename TClientBase>
Austin Borgerc8099762023-01-12 17:08:46 -0800341void Camera2ClientBase<TClientBase>::notifyPhysicalCameraChange(const std::string &physicalId) {
342 // We're only interested in this notification if overrideToPortrait is turned on.
343 if (!TClientBase::mOverrideToPortrait) {
344 return;
345 }
346
Austin Borger1c1bee02023-06-01 16:51:35 -0700347 auto physicalCameraMetadata = mDevice->infoPhysical(physicalId);
Austin Borgerc8099762023-01-12 17:08:46 -0800348 auto orientationEntry = physicalCameraMetadata.find(ANDROID_SENSOR_ORIENTATION);
349
350 if (orientationEntry.count == 1) {
351 int orientation = orientationEntry.data.i32[0];
352 int rotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_NONE;
353
354 if (orientation == 0 || orientation == 180) {
355 rotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_90;
356 }
357
Jayant Chowdhary44d5f622023-09-20 03:11:41 +0000358 static_cast<TClientBase *>(this)->setRotateAndCropOverride(rotateAndCropMode,
359 /*fromHal*/ true);
Austin Borgerc8099762023-01-12 17:08:46 -0800360 }
361}
362
363template <typename TClientBase>
Austin Borger4a870a32022-02-25 01:48:41 +0000364status_t Camera2ClientBase<TClientBase>::notifyActive(float maxPreviewFps) {
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700365 if (!mDeviceActive) {
366 status_t res = TClientBase::startCameraStreamingOps();
367 if (res != OK) {
368 ALOGE("%s: Camera %s: Error starting camera streaming ops: %d", __FUNCTION__,
Austin Borger1c1bee02023-06-01 16:51:35 -0700369 TClientBase::mCameraIdStr.c_str(), res);
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700370 return res;
371 }
Austin Borger74fca042022-05-23 12:41:21 -0700372 mCameraServiceProxyWrapper->logActive(TClientBase::mCameraIdStr, maxPreviewFps);
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700373 }
374 mDeviceActive = true;
375
376 ALOGV("Camera device is now active");
377 return OK;
378}
379
380template <typename TClientBase>
Shuzhen Wangd26b1862022-03-07 12:05:05 -0800381void Camera2ClientBase<TClientBase>::notifyIdleWithUserTag(
Shuzhen Wang316781a2020-08-18 18:11:01 -0700382 int64_t requestCount, int64_t resultErrorCount, bool deviceError,
Shuzhen Wangd26b1862022-03-07 12:05:05 -0800383 const std::vector<hardware::CameraStreamStats>& streamStats,
Shuzhen Wang6e08d202023-10-24 20:27:14 +0000384 const std::string& userTag, int videoStabilizationMode, bool usedUltraWide,
385 bool usedZoomOverride) {
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700386 if (mDeviceActive) {
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700387 status_t res = TClientBase::finishCameraStreamingOps();
388 if (res != OK) {
389 ALOGE("%s: Camera %s: Error finishing streaming ops: %d", __FUNCTION__,
Austin Borger1c1bee02023-06-01 16:51:35 -0700390 TClientBase::mCameraIdStr.c_str(), res);
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700391 }
Austin Borger74fca042022-05-23 12:41:21 -0700392 mCameraServiceProxyWrapper->logIdle(TClientBase::mCameraIdStr,
Shuzhen Wang9372b0b2022-05-11 18:55:19 -0700393 requestCount, resultErrorCount, deviceError, userTag, videoStabilizationMode,
Shuzhen Wang6e08d202023-10-24 20:27:14 +0000394 usedUltraWide, usedZoomOverride, streamStats);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700395 }
396 mDeviceActive = false;
397
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700398 ALOGV("Camera device is now idle");
399}
400
401template <typename TClientBase>
Jing Mikec7f9b132023-03-12 11:12:04 +0800402void Camera2ClientBase<TClientBase>::notifyShutter(
403 [[maybe_unused]] const CaptureResultExtras& resultExtras,
404 [[maybe_unused]] nsecs_t timestamp) {
Jianing Weicb0652e2014-03-12 18:29:36 -0700405 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
406 __FUNCTION__, resultExtras.requestId, timestamp);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800407}
408
409template <typename TClientBase>
Jing Mikec7f9b132023-03-12 11:12:04 +0800410void Camera2ClientBase<TClientBase>::notifyAutoFocus([[maybe_unused]] uint8_t newState,
411 [[maybe_unused]] int triggerId) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800412 ALOGV("%s: Autofocus state now %d, last trigger %d",
413 __FUNCTION__, newState, triggerId);
414
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800415}
416
417template <typename TClientBase>
Jing Mikec7f9b132023-03-12 11:12:04 +0800418void Camera2ClientBase<TClientBase>::notifyAutoExposure([[maybe_unused]] uint8_t newState,
419 [[maybe_unused]] int triggerId) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800420 ALOGV("%s: Autoexposure state now %d, last trigger %d",
421 __FUNCTION__, newState, triggerId);
422}
423
424template <typename TClientBase>
Jing Mikec7f9b132023-03-12 11:12:04 +0800425void Camera2ClientBase<TClientBase>::notifyAutoWhitebalance(
426 [[maybe_unused]] uint8_t newState,
427 [[maybe_unused]] int triggerId) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800428 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
429 __FUNCTION__, newState, triggerId);
430}
431
432template <typename TClientBase>
Jing Mikec7f9b132023-03-12 11:12:04 +0800433void Camera2ClientBase<TClientBase>::notifyPrepared([[maybe_unused]] int streamId) {
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700434 ALOGV("%s: Stream %d now prepared",
435 __FUNCTION__, streamId);
436}
437
438template <typename TClientBase>
Shuzhen Wang9d066012016-09-30 11:30:20 -0700439void Camera2ClientBase<TClientBase>::notifyRequestQueueEmpty() {
440
441 ALOGV("%s: Request queue now empty", __FUNCTION__);
442}
443
444template <typename TClientBase>
Jing Mikec7f9b132023-03-12 11:12:04 +0800445void Camera2ClientBase<TClientBase>::notifyRepeatingRequestError(
446 [[maybe_unused]] long lastFrameNumber) {
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700447 ALOGV("%s: Repeating request was stopped. Last frame number is %ld",
448 __FUNCTION__, lastFrameNumber);
449}
450
451template <typename TClientBase>
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800452int Camera2ClientBase<TClientBase>::getCameraId() const {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800453 return mApi1CameraId;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800454}
455
456template <typename TClientBase>
457const sp<CameraDeviceBase>& Camera2ClientBase<TClientBase>::getCameraDevice() {
458 return mDevice;
459}
460
461template <typename TClientBase>
462const sp<CameraService>& Camera2ClientBase<TClientBase>::getCameraService() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800463 return TClientBase::sCameraService;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800464}
465
466template <typename TClientBase>
467Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::Lock(
468 SharedCameraCallbacks &client) :
469
470 mRemoteCallback(client.mRemoteCallback),
471 mSharedClient(client) {
472
473 mSharedClient.mRemoteCallbackLock.lock();
474}
475
476template <typename TClientBase>
477Camera2ClientBase<TClientBase>::SharedCameraCallbacks::Lock::~Lock() {
478 mSharedClient.mRemoteCallbackLock.unlock();
479}
480
481template <typename TClientBase>
482Camera2ClientBase<TClientBase>::SharedCameraCallbacks::SharedCameraCallbacks(
483 const sp<TCamCallbacks>&client) :
484
485 mRemoteCallback(client) {
486}
487
488template <typename TClientBase>
489typename Camera2ClientBase<TClientBase>::SharedCameraCallbacks&
490Camera2ClientBase<TClientBase>::SharedCameraCallbacks::operator=(
491 const sp<TCamCallbacks>&client) {
492
493 Mutex::Autolock l(mRemoteCallbackLock);
494 mRemoteCallback = client;
495 return *this;
496}
497
498template <typename TClientBase>
499void Camera2ClientBase<TClientBase>::SharedCameraCallbacks::clear() {
500 Mutex::Autolock l(mRemoteCallbackLock);
501 mRemoteCallback.clear();
502}
503
Cliff Wud3a05312021-04-26 23:07:31 +0800504template <typename TClientBase>
Austin Borger1c1bee02023-06-01 16:51:35 -0700505status_t Camera2ClientBase<TClientBase>::injectCamera(const std::string& injectedCamId,
Cliff Wud3a05312021-04-26 23:07:31 +0800506 sp<CameraProviderManager> manager) {
507 return mDevice->injectCamera(injectedCamId, manager);
508}
509
510template <typename TClientBase>
511status_t Camera2ClientBase<TClientBase>::stopInjection() {
512 return mDevice->stopInjection();
513}
514
malikakash22af94c2023-12-04 18:13:14 +0000515template <typename TClientBase>
516status_t Camera2ClientBase<TClientBase>::injectSessionParams(
517 const CameraMetadata& sessionParams) {
518 return mDevice->injectSessionParams(sessionParams);
519}
520
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800521template class Camera2ClientBase<CameraService::Client>;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700522template class Camera2ClientBase<CameraDeviceClientBase>;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800523
524} // namespace android