blob: 3214d4c475faccf1046f45640f2c7a6159747f33 [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
Ruben Brunkd1176ef2014-02-21 10:51:38 -08002 * Copyright (C) 2008 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 */
Mathias Agopian65ab4712010-07-14 17:59:35 -070016
17#ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
18#define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
19
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080020#include <android/hardware/BnCameraService.h>
Michael Grooverd1d435a2018-12-18 17:39:42 -080021#include <android/hardware/BnSensorPrivacyListener.h>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080022#include <android/hardware/ICameraServiceListener.h>
Cliff Wud8cae102021-03-11 01:37:42 +080023#include <android/hardware/camera2/BnCameraInjectionSession.h>
24#include <android/hardware/camera2/ICameraInjectionCallback.h>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080025
Ruben Brunk36597b22015-03-20 22:15:57 -070026#include <cutils/multiuser.h>
Igor Murashkin634a5152013-02-20 17:15:11 -080027#include <utils/Vector.h>
Ruben Brunkb2119af2014-05-09 19:57:56 -070028#include <utils/KeyedVector.h>
Steven Moreland2f348142019-07-02 15:59:07 -070029#include <binder/ActivityManager.h>
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080030#include <binder/AppOpsManager.h>
Mathias Agopian5462fc92010-07-14 18:41:18 -070031#include <binder/BinderService.h>
Kunal Malhotrabfc96052023-02-28 23:25:34 +000032#include <binder/IServiceManager.h>
33#include <binder/IActivityManager.h>
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080034#include <binder/IAppOpsCallback.h>
Svet Ganova453d0d2018-01-11 15:37:58 -080035#include <binder/IUidObserver.h>
Iliyan Malchev8951a972011-04-14 16:55:59 -070036#include <hardware/camera.h>
Steven Moreland3cf67172020-01-29 11:44:22 -080037#include <sensorprivacy/SensorPrivacyManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070038
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -080039#include <android/hardware/camera/common/1.0/types.h>
40
Ruben Brunkd1176ef2014-02-21 10:51:38 -080041#include <camera/VendorTagDescriptor.h>
Jianing Weicb0652e2014-03-12 18:29:36 -070042#include <camera/CaptureResult.h>
Ruben Brunkb2119af2014-05-09 19:57:56 -070043#include <camera/CameraParameters.h>
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -080044#include <camera/camera2/ConcurrentCamera.h>
Igor Murashkinc073ba52013-02-26 14:32:34 -080045
Chien-Yu Chen3068d732015-02-09 13:29:57 -080046#include "CameraFlashlight.h"
47
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080048#include "common/CameraProviderManager.h"
Ronghua Wu022ed722015-05-11 15:15:09 -070049#include "media/RingBuffer.h"
Ruben Brunkcc776712015-02-17 20:18:47 -080050#include "utils/AutoConditionLock.h"
51#include "utils/ClientManager.h"
Jayant Chowdharyffc5d682022-05-12 18:34:34 +000052#include "utils/IPCTransport.h"
Austin Borger74fca042022-05-23 12:41:21 -070053#include "utils/CameraServiceProxyWrapper.h"
Yin-Chia Yehe074a932015-01-30 10:29:02 -080054
Ruben Brunkcc776712015-02-17 20:18:47 -080055#include <set>
56#include <string>
Jayant Chowdhary5e2cd302020-08-14 02:48:34 +000057#include <list>
Ruben Brunkcc776712015-02-17 20:18:47 -080058#include <map>
59#include <memory>
Jooyung Hanb3f7cd22020-01-23 12:27:18 +090060#include <optional>
Ruben Brunk99e69712015-05-26 17:25:07 -070061#include <utility>
Svet Ganova453d0d2018-01-11 15:37:58 -080062#include <unordered_map>
63#include <unordered_set>
Mathias Agopian65ab4712010-07-14 17:59:35 -070064
65namespace android {
66
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -070067extern volatile int32_t gLogLevel;
68
Mathias Agopian65ab4712010-07-14 17:59:35 -070069class MemoryHeapBase;
70class MediaPlayer;
71
Mathias Agopian5462fc92010-07-14 18:41:18 -070072class CameraService :
73 public BinderService<CameraService>,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080074 public virtual ::android::hardware::BnCameraService,
75 public virtual IBinder::DeathRecipient,
Jyoti Bhayanacde601c2022-12-07 10:03:42 -080076 public virtual CameraProviderManager::StatusListener,
77 public virtual IServiceManager::LocalRegistrationCallback
Mathias Agopian65ab4712010-07-14 17:59:35 -070078{
Mathias Agopian5462fc92010-07-14 18:41:18 -070079 friend class BinderService<CameraService>;
Emilian Peevb2bc5a42019-11-20 16:02:14 -080080 friend class CameraOfflineSessionClient;
Mathias Agopian65ab4712010-07-14 17:59:35 -070081public:
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -070082 class Client;
Igor Murashkin634a5152013-02-20 17:15:11 -080083 class BasicClient;
Yin-Chia Yehb978c382019-10-30 00:22:37 -070084 class OfflineClient;
Igor Murashkin634a5152013-02-20 17:15:11 -080085
Ruben Brunk0bbf8b22015-04-30 14:35:42 -070086 // The effective API level. The Camera2 API running in LEGACY mode counts as API_1.
Ruben Brunkcc776712015-02-17 20:18:47 -080087 enum apiLevel {
88 API_1 = 1,
89 API_2 = 2
90 };
91
Ruben Brunkcc776712015-02-17 20:18:47 -080092 // 3 second busy timeout when other clients are connecting
93 static const nsecs_t DEFAULT_CONNECT_TIMEOUT_NS = 3000000000;
94
Ruben Brunk4f9576b2015-04-10 17:26:56 -070095 // 1 second busy timeout when other clients are disconnecting
96 static const nsecs_t DEFAULT_DISCONNECT_TIMEOUT_NS = 1000000000;
97
Ruben Brunkcc776712015-02-17 20:18:47 -080098 // Default number of messages to store in eviction log
Ruben Brunka8ca9152015-04-07 14:23:40 -070099 static const size_t DEFAULT_EVENT_LOG_LENGTH = 100;
Ruben Brunkcc776712015-02-17 20:18:47 -0800100
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800101 // Event log ID
102 static const int SN_EVENT_LOG_ID = 0x534e4554;
103
Charles Chena7b613c2023-01-24 21:57:33 +0000104 // Register camera service
105 static void instantiate();
106
Igor Murashkin634a5152013-02-20 17:15:11 -0800107 // Implementation of BinderService<T>
Mathias Agopian5462fc92010-07-14 18:41:18 -0700108 static char const* getServiceName() { return "media.camera"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700109
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800110 // Implementation of IServiceManager::LocalRegistrationCallback
111 virtual void onServiceRegistration(const String16& name, const sp<IBinder>& binder) override;
112
Austin Borger74fca042022-05-23 12:41:21 -0700113 // Non-null arguments for cameraServiceProxyWrapper should be provided for
114 // testing purposes only.
115 CameraService(std::shared_ptr<CameraServiceProxyWrapper>
116 cameraServiceProxyWrapper = nullptr);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700117 virtual ~CameraService();
118
Igor Murashkin634a5152013-02-20 17:15:11 -0800119 /////////////////////////////////////////////////////////////////////
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800120 // HAL Callbacks - implements CameraProviderManager::StatusListener
121
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800122 virtual void onDeviceStatusChanged(const String8 &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700123 CameraDeviceStatus newHalStatus) override;
Shuzhen Wang43858162020-01-10 13:42:15 -0800124 virtual void onDeviceStatusChanged(const String8 &cameraId,
125 const String8 &physicalCameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700126 CameraDeviceStatus newHalStatus) override;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -0700127 // This method may hold CameraProviderManager::mInterfaceMutex as a part
128 // of calling getSystemCameraKind() internally. Care should be taken not to
129 // directly / indirectly call this from callers who also hold
130 // mInterfaceMutex.
Chien-Yu Chen88da5262015-02-17 13:56:46 -0800131 virtual void onTorchStatusChanged(const String8& cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700132 TorchModeStatus newStatus) override;
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -0700133 // Does not hold CameraProviderManager::mInterfaceMutex.
134 virtual void onTorchStatusChanged(const String8& cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700135 TorchModeStatus newStatus,
Jayant Chowdhary46ef0f52021-10-05 14:36:13 -0700136 SystemCameraKind kind) override;
Emilian Peevaee727d2017-05-04 16:35:48 +0100137 virtual void onNewProviderRegistered() override;
Igor Murashkincba2c162013-03-20 15:56:31 -0700138
139 /////////////////////////////////////////////////////////////////////
Igor Murashkin634a5152013-02-20 17:15:11 -0800140 // ICameraService
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800141 virtual binder::Status getNumberOfCameras(int32_t type, int32_t* numCameras);
Eino-Ville Talvalabad43582015-08-14 13:12:32 -0700142
Austin Borger18b30a72022-10-27 12:20:29 -0700143 virtual binder::Status getCameraInfo(int cameraId, bool overrideToPortrait,
144 hardware::CameraInfo* cameraInfo) override;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800145 virtual binder::Status getCameraCharacteristics(const String16& cameraId,
Austin Borger18b30a72022-10-27 12:20:29 -0700146 int targetSdkVersion, bool overrideToPortrait, CameraMetadata* cameraInfo) override;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800147 virtual binder::Status getCameraVendorTagDescriptor(
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700148 /*out*/
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800149 hardware::camera2::params::VendorTagDescriptor* desc);
Emilian Peev71c73a22017-03-21 16:35:51 +0000150 virtual binder::Status getCameraVendorTagCache(
151 /*out*/
152 hardware::camera2::params::VendorTagDescriptorCache* cache);
Ruben Brunk0f61d8f2013-08-08 13:07:18 -0700153
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800154 virtual binder::Status connect(const sp<hardware::ICameraClient>& cameraClient,
155 int32_t cameraId, const String16& clientPackageName,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700156 int32_t clientUid, int clientPid, int targetSdkVersion,
Chengfei Taobe683db2023-01-31 18:52:49 +0000157 bool overrideToPortrait, bool forceSlowJpegMode,
Zhijun Heb10cdad2014-06-16 16:38:35 -0700158 /*out*/
Austin Borger18b30a72022-10-27 12:20:29 -0700159 sp<hardware::ICamera>* device) override;
Zhijun Heb10cdad2014-06-16 16:38:35 -0700160
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800161 virtual binder::Status connectDevice(
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800162 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, const String16& cameraId,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900163 const String16& clientPackageName, const std::optional<String16>& clientFeatureId,
Austin Borger18b30a72022-10-27 12:20:29 -0700164 int32_t clientUid, int scoreOffset, int targetSdkVersion, bool overrideToPortrait,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800165 /*out*/
166 sp<hardware::camera2::ICameraDeviceUser>* device);
Igor Murashkinbfc99152013-02-27 12:55:20 -0800167
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800168 virtual binder::Status addListener(const sp<hardware::ICameraServiceListener>& listener,
169 /*out*/
170 std::vector<hardware::CameraStatus>* cameraStatuses);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800171 virtual binder::Status removeListener(
172 const sp<hardware::ICameraServiceListener>& listener);
173
Jayant Chowdharycad23c22020-03-10 15:04:59 -0700174 virtual binder::Status getConcurrentCameraIds(
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800175 /*out*/
176 std::vector<hardware::camera2::utils::ConcurrentCameraIdCombination>* concurrentCameraIds);
177
178 virtual binder::Status isConcurrentSessionConfigurationSupported(
179 const std::vector<hardware::camera2::utils::CameraIdAndSessionConfiguration>& sessions,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700180 int targetSdkVersion, /*out*/bool* supported);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800181
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800182 virtual binder::Status getLegacyParameters(
183 int32_t cameraId,
Igor Murashkin65d14b92014-06-17 12:03:20 -0700184 /*out*/
185 String16* parameters);
186
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800187 virtual binder::Status setTorchMode(const String16& cameraId, bool enabled,
Chien-Yu Chen3068d732015-02-09 13:29:57 -0800188 const sp<IBinder>& clientBinder);
189
Rucha Katakwar38284522021-11-10 11:25:21 -0800190 virtual binder::Status turnOnTorchWithStrengthLevel(const String16& cameraId,
191 int32_t torchStrength, const sp<IBinder>& clientBinder);
192
193 virtual binder::Status getTorchStrengthLevel(const String16& cameraId,
194 int32_t* torchStrength);
195
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800196 virtual binder::Status notifySystemEvent(int32_t eventId,
197 const std::vector<int32_t>& args);
Ruben Brunk36597b22015-03-20 22:15:57 -0700198
Eino-Ville Talvala63f36112018-12-06 14:57:03 -0800199 virtual binder::Status notifyDeviceStateChange(int64_t newState);
200
Emilian Peev8b64f282021-03-25 16:49:57 -0700201 virtual binder::Status notifyDisplayConfigurationChange();
202
Igor Murashkin65d14b92014-06-17 12:03:20 -0700203 // OK = supports api of that version, -EOPNOTSUPP = does not support
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800204 virtual binder::Status supportsCameraApi(
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800205 const String16& cameraId, int32_t apiVersion,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800206 /*out*/
207 bool *isSupported);
Igor Murashkin65d14b92014-06-17 12:03:20 -0700208
Shuzhen Wangf9d2c022018-08-21 12:07:35 -0700209 virtual binder::Status isHiddenPhysicalCamera(
210 const String16& cameraId,
211 /*out*/
212 bool *isSupported);
213
Cliff Wud8cae102021-03-11 01:37:42 +0800214 virtual binder::Status injectCamera(
215 const String16& packageName, const String16& internalCamId,
216 const String16& externalCamId,
217 const sp<hardware::camera2::ICameraInjectionCallback>& callback,
218 /*out*/
219 sp<hardware::camera2::ICameraInjectionSession>* cameraInjectionSession);
220
Avichal Rakesh6e57a2b2023-05-01 17:53:37 -0700221 virtual binder::Status reportExtensionSessionStats(
222 const hardware::CameraExtensionSessionStats& stats, String16* sessionKey /*out*/);
223
Igor Murashkin634a5152013-02-20 17:15:11 -0800224 // Extra permissions checks
Mathias Agopian65ab4712010-07-14 17:59:35 -0700225 virtual status_t onTransact(uint32_t code, const Parcel& data,
226 Parcel* reply, uint32_t flags);
Igor Murashkin634a5152013-02-20 17:15:11 -0800227
228 virtual status_t dump(int fd, const Vector<String16>& args);
229
Svet Ganova453d0d2018-01-11 15:37:58 -0800230 virtual status_t shellCommand(int in, int out, int err, const Vector<String16>& args);
231
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800232 binder::Status addListenerHelper(const sp<hardware::ICameraServiceListener>& listener,
233 /*out*/
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -0700234 std::vector<hardware::CameraStatus>* cameraStatuses, bool isVendor = false,
235 bool isProcessLocalTest = false);
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800236
Emilian Peev53722fa2019-02-22 17:47:20 -0800237 // Monitored UIDs availability notification
238 void notifyMonitoredUids();
Austin Borgerdddb7552023-03-30 17:53:01 -0700239 void notifyMonitoredUids(const std::unordered_set<uid_t> &notifyUidSet);
Emilian Peev53722fa2019-02-22 17:47:20 -0800240
Rucha Katakwardf223072021-06-15 10:21:00 -0700241 // Stores current open session device info in temp file.
242 void cacheDump();
243
Emilian Peevb2bc5a42019-11-20 16:02:14 -0800244 // Register an offline client for a given active camera id
245 status_t addOfflineClient(String8 cameraId, sp<BasicClient> offlineClient);
246
Igor Murashkin634a5152013-02-20 17:15:11 -0800247 /////////////////////////////////////////////////////////////////////
248 // Client functionality
Mathias Agopian65ab4712010-07-14 17:59:35 -0700249
250 enum sound_kind {
251 SOUND_SHUTTER = 0,
Chien-Yu Chen82104eb2015-10-14 11:29:31 -0700252 SOUND_RECORDING_START = 1,
253 SOUND_RECORDING_STOP = 2,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700254 NUM_SOUNDS
255 };
256
Mathias Agopian65ab4712010-07-14 17:59:35 -0700257 void playSound(sound_kind kind);
username5755fea2018-12-27 09:48:08 +0800258 void loadSoundLocked(sound_kind kind);
259 void decreaseSoundRef();
260 void increaseSoundRef();
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700261
Igor Murashkin98e24722013-06-19 19:51:04 -0700262 /////////////////////////////////////////////////////////////////////
263 // CameraDeviceFactory functionality
Austin Borger18b30a72022-10-27 12:20:29 -0700264 std::pair<int, IPCTransport> getDeviceVersion(const String8& cameraId,
265 bool overrideToPortrait, int* portraitRotation,
266 int* facing = nullptr, int* orientation = nullptr);
Igor Murashkin98e24722013-06-19 19:51:04 -0700267
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700268 /////////////////////////////////////////////////////////////////////
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -0700269 // Methods to be used in CameraService class tests only
270 //
271 // CameraService class test method only - clear static variables in the
272 // cameraserver process, which otherwise might affect multiple test runs.
273 void clearCachedVariables();
274
275 // Add test listener, linkToDeath won't be called since this is for process
276 // local testing.
277 binder::Status addListenerTest(const sp<hardware::ICameraServiceListener>& listener,
278 /*out*/
279 std::vector<hardware::CameraStatus>* cameraStatuses);
280
281 /////////////////////////////////////////////////////////////////////
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700282 // Shared utilities
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800283 static binder::Status filterGetInfoErrorCode(status_t err);
Igor Murashkin634a5152013-02-20 17:15:11 -0800284
285 /////////////////////////////////////////////////////////////////////
286 // CameraClient functionality
287
Igor Murashkin634a5152013-02-20 17:15:11 -0800288 class BasicClient : public virtual RefBase {
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -0700289 friend class CameraService;
Igor Murashkin634a5152013-02-20 17:15:11 -0800290 public:
Emilian Peevbd8c5032018-02-14 23:05:40 +0000291 virtual status_t initialize(sp<CameraProviderManager> manager,
292 const String8& monitorTags) = 0;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800293 virtual binder::Status disconnect();
Igor Murashkin634a5152013-02-20 17:15:11 -0800294
Igor Murashkine7ee7632013-06-11 18:10:18 -0700295 // because we can't virtually inherit IInterface, which breaks
296 // virtual inheritance
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800297 virtual sp<IBinder> asBinderWrapper() = 0;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700298
Ruben Brunk9efdf952015-03-18 23:11:57 -0700299 // Return the remote callback binder object (e.g. ICameraDeviceCallbacks)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800300 sp<IBinder> getRemote() {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800301 return mRemoteBinder;
Igor Murashkin634a5152013-02-20 17:15:11 -0800302 }
303
Austin Borger18b30a72022-10-27 12:20:29 -0700304 bool getOverrideToPortrait() const {
305 return mOverrideToPortrait;
306 }
307
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800308 // Disallows dumping over binder interface
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800309 virtual status_t dump(int fd, const Vector<String16>& args);
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800310 // Internal dump method to be called by CameraService
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800311 virtual status_t dumpClient(int fd, const Vector<String16>& args) = 0;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700312
Avichal Rakesh7e53cad2021-10-05 13:46:30 -0700313 virtual status_t startWatchingTags(const String8 &tags, int outFd);
314 virtual status_t stopWatchingTags(int outFd);
315 virtual status_t dumpWatchedEventsToVector(std::vector<std::string> &out);
316
Ruben Brunkcc776712015-02-17 20:18:47 -0800317 // Return the package name for this client
318 virtual String16 getPackageName() const;
319
Emilian Peev8b64f282021-03-25 16:49:57 -0700320 // Return the camera facing for this client
321 virtual int getCameraFacing() const;
322
323 // Return the camera orientation for this client
324 virtual int getCameraOrientation() const;
325
Ruben Brunkcc776712015-02-17 20:18:47 -0800326 // Notify client about a fatal error
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800327 virtual void notifyError(int32_t errorCode,
Ruben Brunkcc776712015-02-17 20:18:47 -0800328 const CaptureResultExtras& resultExtras) = 0;
329
Ruben Brunk6267b532015-04-30 17:44:07 -0700330 // Get the UID of the application client using this
331 virtual uid_t getClientUid() const;
332
Ruben Brunkcc776712015-02-17 20:18:47 -0800333 // Get the PID of the application client using this
334 virtual int getClientPid() const;
Ruben Brunk0bbf8b22015-04-30 14:35:42 -0700335
336 // Check what API level is used for this client. This is used to determine which
337 // superclass this can be cast to.
338 virtual bool canCastToApiClient(apiLevel level) const;
Svet Ganova453d0d2018-01-11 15:37:58 -0800339
340 // Block the client form using the camera
341 virtual void block();
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700342
343 // set audio restriction from client
344 // Will call into camera service and hold mServiceLock
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -0700345 virtual status_t setAudioRestriction(int32_t mode);
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700346
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -0700347 // Get current global audio restriction setting
348 // Will call into camera service and hold mServiceLock
349 virtual int32_t getServiceAudioRestriction() const;
350
351 // Get current audio restriction setting for this client
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700352 virtual int32_t getAudioRestriction() const;
353
354 static bool isValidAudioRestriction(int32_t mode);
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800355
356 // Override rotate-and-crop AUTO behavior
357 virtual status_t setRotateAndCropOverride(uint8_t rotateAndCrop) = 0;
358
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000359 // Override autoframing AUTO behaviour
360 virtual status_t setAutoframingOverride(uint8_t autoframingValue) = 0;
361
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800362 // Whether the client supports camera muting (black only output)
363 virtual bool supportsCameraMute() = 0;
364
365 // Set/reset camera mute
366 virtual status_t setCameraMute(bool enabled) = 0;
367
Ravneetaeb20dc2022-03-30 05:33:03 +0000368 // Set Camera service watchdog
369 virtual status_t setCameraServiceWatchdog(bool enabled) = 0;
370
Shuzhen Wang16610a62022-12-15 22:38:07 -0800371 // Set stream use case overrides
372 virtual void setStreamUseCaseOverrides(
373 const std::vector<int64_t>& useCaseOverrides) = 0;
374
375 // Clear stream use case overrides
376 virtual void clearStreamUseCaseOverrides() = 0;
377
Shuzhen Wangaf22e912023-04-11 16:03:17 -0700378 // Whether the client supports camera zoom override
379 virtual bool supportsZoomOverride() = 0;
380
381 // Set/reset zoom override
382 virtual status_t setZoomOverride(int32_t zoomOverride) = 0;
383
Cliff Wud3a05312021-04-26 23:07:31 +0800384 // The injection camera session to replace the internal camera
385 // session.
386 virtual status_t injectCamera(const String8& injectedCamId,
387 sp<CameraProviderManager> manager) = 0;
388
389 // Stop the injection camera and restore to internal camera session.
390 virtual status_t stopInjection() = 0;
391
Igor Murashkin634a5152013-02-20 17:15:11 -0800392 protected:
393 BasicClient(const sp<CameraService>& cameraService,
394 const sp<IBinder>& remoteCallback,
Svetoslav Ganov280405a2015-05-12 02:19:27 +0000395 const String16& clientPackageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800396 bool nativeClient,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900397 const std::optional<String16>& clientFeatureId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800398 const String8& cameraIdStr,
Igor Murashkin634a5152013-02-20 17:15:11 -0800399 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -0700400 int sensorOrientation,
Igor Murashkin634a5152013-02-20 17:15:11 -0800401 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800402 uid_t clientUid,
Austin Borger18b30a72022-10-27 12:20:29 -0700403 int servicePid,
404 bool overrideToPortrait);
Igor Murashkin634a5152013-02-20 17:15:11 -0800405
406 virtual ~BasicClient();
407
408 // the instance is in the middle of destruction. When this is set,
409 // the instance should not be accessed from callback.
410 // CameraService's mClientLock should be acquired to access this.
411 // - subclasses should set this to true in their destructors.
412 bool mDestructionStarted;
413
414 // these are initialized in the constructor.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800415 static sp<CameraService> sCameraService;
416 const String8 mCameraIdStr;
417 const int mCameraFacing;
Emilian Peev8b64f282021-03-25 16:49:57 -0700418 const int mOrientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800419 String16 mClientPackageName;
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800420 bool mSystemNativeClient;
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900421 std::optional<String16> mClientFeatureId;
Igor Murashkin634a5152013-02-20 17:15:11 -0800422 pid_t mClientPid;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800423 const uid_t mClientUid;
424 const pid_t mServicePid;
Ruben Brunkcc776712015-02-17 20:18:47 -0800425 bool mDisconnected;
Shuzhen Wang2c656792020-04-13 17:36:49 -0700426 bool mUidIsTrusted;
Austin Borger18b30a72022-10-27 12:20:29 -0700427 bool mOverrideToPortrait;
Igor Murashkin634a5152013-02-20 17:15:11 -0800428
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700429 mutable Mutex mAudioRestrictionLock;
430 int32_t mAudioRestriction;
431
Igor Murashkin634a5152013-02-20 17:15:11 -0800432 // - The app-side Binder interface to receive callbacks from us
Igor Murashkine7ee7632013-06-11 18:10:18 -0700433 sp<IBinder> mRemoteBinder; // immutable after constructor
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800434
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700435 // Permissions management methods for camera lifecycle
436
437 // Notify rest of system/apps about camera opening, and check appops
Emilian Peevb2bc5a42019-11-20 16:02:14 -0800438 virtual status_t startCameraOps();
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700439 // Notify rest of system/apps about camera starting to stream data, and confirm appops
440 virtual status_t startCameraStreamingOps();
441 // Notify rest of system/apps about camera stopping streaming data
442 virtual status_t finishCameraStreamingOps();
443 // Notify rest of system/apps about camera closing
Emilian Peevb2bc5a42019-11-20 16:02:14 -0800444 virtual status_t finishCameraOps();
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700445 // Handle errors for start/checkOps
446 virtual status_t handleAppOpMode(int32_t mode);
Valentin Iftimec0b8d472021-07-23 20:21:06 +0200447 // Just notify camera appops to trigger unblocking dialog if sensor
448 // privacy is enabled and camera mute is not supported
449 virtual status_t noteAppOp();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800450
Jayant Chowdharyb61526c2019-05-13 19:37:42 -0700451 std::unique_ptr<AppOpsManager> mAppOpsManager = nullptr;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800452
453 class OpsCallback : public BnAppOpsCallback {
454 public:
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700455 explicit OpsCallback(wp<BasicClient> client);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800456 virtual void opChanged(int32_t op, const String16& packageName);
457
458 private:
459 wp<BasicClient> mClient;
460
461 }; // class OpsCallback
462
463 sp<OpsCallback> mOpsCallback;
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700464 // Track whether checkOps was called successfully, to avoid
465 // finishing what we didn't start, on camera open.
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800466 bool mOpsActive;
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700467 // Track whether startOps was called successfully on start of
468 // camera streaming.
469 bool mOpsStreaming;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800470
471 // IAppOpsCallback interface, indirected through opListener
472 virtual void opChanged(int32_t op, const String16& packageName);
473 }; // class BasicClient
Igor Murashkin634a5152013-02-20 17:15:11 -0800474
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800475 class Client : public hardware::BnCamera, public BasicClient
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700476 {
477 public:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800478 typedef hardware::ICameraClient TCamCallbacks;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800479
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700480 // ICamera interface (see ICamera for details)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800481 virtual binder::Status disconnect();
482 virtual status_t connect(const sp<hardware::ICameraClient>& client) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700483 virtual status_t lock() = 0;
484 virtual status_t unlock() = 0;
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700485 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700486 virtual void setPreviewCallbackFlag(int flag) = 0;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700487 virtual status_t setPreviewCallbackTarget(
488 const sp<IGraphicBufferProducer>& callbackProducer) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700489 virtual status_t startPreview() = 0;
490 virtual void stopPreview() = 0;
491 virtual bool previewEnabled() = 0;
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800492 virtual status_t setVideoBufferMode(int32_t videoBufferMode) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700493 virtual status_t startRecording() = 0;
494 virtual void stopRecording() = 0;
495 virtual bool recordingEnabled() = 0;
496 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0;
497 virtual status_t autoFocus() = 0;
498 virtual status_t cancelAutoFocus() = 0;
499 virtual status_t takePicture(int msgType) = 0;
500 virtual status_t setParameters(const String8& params) = 0;
501 virtual String8 getParameters() const = 0;
502 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800503 virtual status_t setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700504
505 // Interface used by CameraService
506 Client(const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800507 const sp<hardware::ICameraClient>& cameraClient,
Svetoslav Ganov280405a2015-05-12 02:19:27 +0000508 const String16& clientPackageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800509 bool systemNativeClient,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900510 const std::optional<String16>& clientFeatureId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800511 const String8& cameraIdStr,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800512 int api1CameraId,
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700513 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -0700514 int sensorOrientation,
Igor Murashkinecf17e82012-10-02 16:05:11 -0700515 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800516 uid_t clientUid,
Austin Borger18b30a72022-10-27 12:20:29 -0700517 int servicePid,
518 bool overrideToPortrait);
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700519 ~Client();
520
521 // return our camera client
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800522 const sp<hardware::ICameraClient>& getRemoteCallback() {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800523 return mRemoteCallback;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700524 }
525
Igor Murashkine7ee7632013-06-11 18:10:18 -0700526 virtual sp<IBinder> asBinderWrapper() {
Marco Nelissen06b46062014-11-14 07:58:25 -0800527 return asBinder(this);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700528 }
529
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800530 virtual void notifyError(int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -0700531 const CaptureResultExtras& resultExtras);
Ruben Brunk0bbf8b22015-04-30 14:35:42 -0700532
533 // Check what API level is used for this client. This is used to determine which
534 // superclass this can be cast to.
535 virtual bool canCastToApiClient(apiLevel level) const;
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800536
537 void setImageDumpMask(int /*mask*/) { }
Ruben Brunkcc776712015-02-17 20:18:47 -0800538 protected:
Igor Murashkin634a5152013-02-20 17:15:11 -0800539 // Initialized in constructor
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700540
Igor Murashkin634a5152013-02-20 17:15:11 -0800541 // - The app-side Binder interface to receive callbacks from us
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800542 sp<hardware::ICameraClient> mRemoteCallback;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800543
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800544 int mCameraId; // All API1 clients use integer camera IDs
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800545 }; // class Client
Igor Murashkin634a5152013-02-20 17:15:11 -0800546
Ruben Brunk99e69712015-05-26 17:25:07 -0700547 /**
548 * A listener class that implements the LISTENER interface for use with a ClientManager, and
549 * implements the following methods:
550 * void onClientRemoved(const ClientDescriptor<KEY, VALUE>& descriptor);
551 * void onClientAdded(const ClientDescriptor<KEY, VALUE>& descriptor);
552 */
553 class ClientEventListener {
554 public:
555 void onClientAdded(const resource_policy::ClientDescriptor<String8,
556 sp<CameraService::BasicClient>>& descriptor);
557 void onClientRemoved(const resource_policy::ClientDescriptor<String8,
558 sp<CameraService::BasicClient>>& descriptor);
559 }; // class ClientEventListener
560
Ruben Brunkcc776712015-02-17 20:18:47 -0800561 typedef std::shared_ptr<resource_policy::ClientDescriptor<String8,
562 sp<CameraService::BasicClient>>> DescriptorPtr;
563
564 /**
565 * A container class for managing active camera clients that are using HAL devices. Active
566 * clients are represented by ClientDescriptor objects that contain strong pointers to the
567 * actual BasicClient subclass binder interface implementation.
568 *
569 * This class manages the eviction behavior for the camera clients. See the parent class
570 * implementation in utils/ClientManager for the specifics of this behavior.
571 */
Ruben Brunk99e69712015-05-26 17:25:07 -0700572 class CameraClientManager : public resource_policy::ClientManager<String8,
573 sp<CameraService::BasicClient>, ClientEventListener> {
Ruben Brunkcc776712015-02-17 20:18:47 -0800574 public:
Ruben Brunk99e69712015-05-26 17:25:07 -0700575 CameraClientManager();
Ruben Brunkcc776712015-02-17 20:18:47 -0800576 virtual ~CameraClientManager();
577
578 /**
579 * Return a strong pointer to the active BasicClient for this camera ID, or an empty
580 * if none exists.
581 */
582 sp<CameraService::BasicClient> getCameraClient(const String8& id) const;
583
584 /**
585 * Return a string describing the current state.
586 */
587 String8 toString() const;
588
589 /**
590 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer.
591 */
592 static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value,
Emilian Peev8131a262017-02-01 12:33:43 +0000593 int32_t cost, const std::set<String8>& conflictingKeys, int32_t score,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800594 int32_t ownerId, int32_t state, int oomScoreOffset, bool systemNativeClient);
Ruben Brunkcc776712015-02-17 20:18:47 -0800595
596 /**
597 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with
598 * values intialized from a prior ClientDescriptor.
599 */
600 static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800601 const CameraService::DescriptorPtr& partial, int oomScoreOffset,
602 bool systemNativeClient);
Ruben Brunkcc776712015-02-17 20:18:47 -0800603
604 }; // class CameraClientManager
605
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700606 int32_t updateAudioRestriction();
607 int32_t updateAudioRestrictionLocked();
608
Mathias Agopian65ab4712010-07-14 17:59:35 -0700609private:
Igor Murashkin634a5152013-02-20 17:15:11 -0800610
Kunal Malhotrabfc96052023-02-28 23:25:34 +0000611 // TODO: b/263304156 update this to make use of a death callback for more
612 // robust/fault tolerant logging
613 static const sp<IActivityManager>& getActivityManager() {
614 static const char* kActivityService = "activity";
615 static const auto activityManager = []() -> sp<IActivityManager> {
616 const sp<IServiceManager> sm(defaultServiceManager());
617 if (sm != nullptr) {
618 return interface_cast<IActivityManager>(sm->checkService(String16(kActivityService)));
619 }
620 return nullptr;
621 }();
622 return activityManager;
623 }
624
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800625 /**
626 * Typesafe version of device status, containing both the HAL-layer and the service interface-
627 * layer values.
628 */
629 enum class StatusInternal : int32_t {
630 NOT_PRESENT = static_cast<int32_t>(CameraDeviceStatus::NOT_PRESENT),
631 PRESENT = static_cast<int32_t>(CameraDeviceStatus::PRESENT),
632 ENUMERATING = static_cast<int32_t>(CameraDeviceStatus::ENUMERATING),
633 NOT_AVAILABLE = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE),
634 UNKNOWN = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_UNKNOWN)
635 };
636
Ruben Brunkcc776712015-02-17 20:18:47 -0800637 /**
638 * Container class for the state of each logical camera device, including: ID, status, and
639 * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates
640 * represents the camera devices advertised by the HAL (and any USB devices, when we add
641 * those).
642 *
643 * This container does NOT represent an active camera client. These are represented using
644 * the ClientDescriptors stored in mActiveClientManager.
645 */
646 class CameraState {
647 public:
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800648
Ruben Brunkcc776712015-02-17 20:18:47 -0800649 /**
650 * Make a new CameraState and set the ID, cost, and conflicting devices using the values
651 * returned in the HAL's camera_info struct for each device.
652 */
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700653 CameraState(const String8& id, int cost, const std::set<String8>& conflicting,
Shuzhen Wang403af6d2021-12-21 00:08:43 +0000654 SystemCameraKind deviceKind, const std::vector<std::string>& physicalCameras);
Ruben Brunkcc776712015-02-17 20:18:47 -0800655 virtual ~CameraState();
656
657 /**
658 * Return the status for this device.
659 *
660 * This method acquires mStatusLock.
661 */
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800662 StatusInternal getStatus() const;
Ruben Brunkcc776712015-02-17 20:18:47 -0800663
664 /**
665 * This function updates the status for this camera device, unless the given status
666 * is in the given list of rejected status states, and execute the function passed in
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800667 * with a signature onStatusUpdateLocked(const String8&, int32_t)
Ruben Brunkcc776712015-02-17 20:18:47 -0800668 * if the status has changed.
669 *
670 * This method is idempotent, and will not result in the function passed to
671 * onStatusUpdateLocked being called more than once for the same arguments.
672 * This method aquires mStatusLock.
673 */
674 template<class Func>
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800675 void updateStatus(StatusInternal status,
676 const String8& cameraId,
677 std::initializer_list<StatusInternal> rejectSourceStates,
Ruben Brunkcc776712015-02-17 20:18:47 -0800678 Func onStatusUpdatedLocked);
679
680 /**
681 * Return the last set CameraParameters object generated from the information returned by
682 * the HAL for this device (or an empty CameraParameters object if none has been set).
683 */
684 CameraParameters getShimParams() const;
685
686 /**
687 * Set the CameraParameters for this device.
688 */
689 void setShimParams(const CameraParameters& params);
690
691 /**
692 * Return the resource_cost advertised by the HAL for this device.
693 */
694 int getCost() const;
695
696 /**
697 * Return a set of the IDs of conflicting devices advertised by the HAL for this device.
698 */
699 std::set<String8> getConflicting() const;
700
701 /**
702 * Return the ID of this camera device.
703 */
704 String8 getId() const;
705
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700706 /**
707 * Return the kind (SystemCameraKind) of this camera device.
708 */
709 SystemCameraKind getSystemCameraKind() const;
710
Shuzhen Wang43858162020-01-10 13:42:15 -0800711 /**
Shuzhen Wang403af6d2021-12-21 00:08:43 +0000712 * Return whether this camera is a logical multi-camera and has a
713 * particular physical sub-camera.
714 */
715 bool containsPhysicalCamera(const std::string& physicalCameraId) const;
716
717 /**
Shuzhen Wang43858162020-01-10 13:42:15 -0800718 * Add/Remove the unavailable physical camera ID.
719 */
720 bool addUnavailablePhysicalId(const String8& physicalId);
721 bool removeUnavailablePhysicalId(const String8& physicalId);
722
723 /**
Shuzhen Wange7aa0342021-08-03 11:29:47 -0700724 * Set and get client package name.
725 */
726 void setClientPackage(const String8& clientPackage);
727 String8 getClientPackage() const;
728
729 /**
Shuzhen Wang43858162020-01-10 13:42:15 -0800730 * Return the unavailable physical ids for this device.
731 *
732 * This method acquires mStatusLock.
733 */
734 std::vector<String8> getUnavailablePhysicalIds() const;
Ruben Brunkcc776712015-02-17 20:18:47 -0800735 private:
736 const String8 mId;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800737 StatusInternal mStatus; // protected by mStatusLock
Ruben Brunkcc776712015-02-17 20:18:47 -0800738 const int mCost;
739 std::set<String8> mConflicting;
Shuzhen Wang43858162020-01-10 13:42:15 -0800740 std::set<String8> mUnavailablePhysicalIds;
Shuzhen Wange7aa0342021-08-03 11:29:47 -0700741 String8 mClientPackage;
Ruben Brunkcc776712015-02-17 20:18:47 -0800742 mutable Mutex mStatusLock;
743 CameraParameters mShimParams;
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700744 const SystemCameraKind mSystemCameraKind;
Shuzhen Wang403af6d2021-12-21 00:08:43 +0000745 const std::vector<std::string> mPhysicalCameras; // Empty if not a logical multi-camera
Ruben Brunkcc776712015-02-17 20:18:47 -0800746 }; // class CameraState
747
Svet Ganova453d0d2018-01-11 15:37:58 -0800748 // Observer for UID lifecycle enforcing that UIDs in idle
749 // state cannot use the camera to protect user privacy.
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800750 class UidPolicy :
751 public BnUidObserver,
752 public virtual IBinder::DeathRecipient,
753 public virtual IServiceManager::LocalRegistrationCallback {
Svet Ganova453d0d2018-01-11 15:37:58 -0800754 public:
755 explicit UidPolicy(sp<CameraService> service)
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -0700756 : mRegistered(false), mService(service) {}
Svet Ganova453d0d2018-01-11 15:37:58 -0800757
758 void registerSelf();
759 void unregisterSelf();
760
Svet Ganov7b4ab782018-03-25 12:48:10 -0700761 bool isUidActive(uid_t uid, String16 callingPackage);
Varun Shahb42f1eb2019-04-16 14:45:13 -0700762 int32_t getProcState(uid_t uid);
Svet Ganova453d0d2018-01-11 15:37:58 -0800763
Austin Borger65577682022-02-17 00:25:43 +0000764 // IUidObserver
765 void onUidGone(uid_t uid, bool disabled) override;
766 void onUidActive(uid_t uid) override;
767 void onUidIdle(uid_t uid, bool disabled) override;
Hui Yu13ad0eb2019-09-09 10:27:07 -0700768 void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq,
Austin Borger65577682022-02-17 00:25:43 +0000769 int32_t capability) override;
Austin Borgerdddb7552023-03-30 17:53:01 -0700770 void onUidProcAdjChanged(uid_t uid, int adj) override;
Svet Ganova453d0d2018-01-11 15:37:58 -0800771
Svet Ganov7b4ab782018-03-25 12:48:10 -0700772 void addOverrideUid(uid_t uid, String16 callingPackage, bool active);
773 void removeOverrideUid(uid_t uid, String16 callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -0800774
Austin Borgerdddb7552023-03-30 17:53:01 -0700775 void registerMonitorUid(uid_t uid, bool openCamera);
776 void unregisterMonitorUid(uid_t uid, bool closeCamera);
Emilian Peev53722fa2019-02-22 17:47:20 -0800777
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800778 // Implementation of IServiceManager::LocalRegistrationCallback
779 virtual void onServiceRegistration(const String16& name,
780 const sp<IBinder>& binder) override;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -0700781 // IBinder::DeathRecipient implementation
782 virtual void binderDied(const wp<IBinder> &who);
Svet Ganova453d0d2018-01-11 15:37:58 -0800783 private:
Svet Ganov7b4ab782018-03-25 12:48:10 -0700784 bool isUidActiveLocked(uid_t uid, String16 callingPackage);
Varun Shahb42f1eb2019-04-16 14:45:13 -0700785 int32_t getProcStateLocked(uid_t uid);
Svet Ganov7b4ab782018-03-25 12:48:10 -0700786 void updateOverrideUid(uid_t uid, String16 callingPackage, bool active, bool insert);
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800787 void registerWithActivityManager();
Svet Ganova453d0d2018-01-11 15:37:58 -0800788
Austin Borger65577682022-02-17 00:25:43 +0000789 struct MonitoredUid {
790 int32_t procState;
Austin Borgerdddb7552023-03-30 17:53:01 -0700791 int32_t procAdj;
792 bool hasCamera;
Austin Borger65577682022-02-17 00:25:43 +0000793 size_t refCount;
794 };
795
Svet Ganova453d0d2018-01-11 15:37:58 -0800796 Mutex mUidLock;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -0700797 bool mRegistered;
Steven Moreland2f348142019-07-02 15:59:07 -0700798 ActivityManager mAm;
Svet Ganova453d0d2018-01-11 15:37:58 -0800799 wp<CameraService> mService;
800 std::unordered_set<uid_t> mActiveUids;
Austin Borger65577682022-02-17 00:25:43 +0000801 // Monitored uid map
802 std::unordered_map<uid_t, MonitoredUid> mMonitoredUids;
Svet Ganova453d0d2018-01-11 15:37:58 -0800803 std::unordered_map<uid_t, bool> mOverrideUids;
Austin Borgerd0309d42023-04-21 20:07:18 -0700804 sp<IBinder> mObserverToken;
Svet Ganova453d0d2018-01-11 15:37:58 -0800805 }; // class UidPolicy
806
Michael Grooverd1d435a2018-12-18 17:39:42 -0800807 // If sensor privacy is enabled then all apps, including those that are active, should be
808 // prevented from accessing the camera.
809 class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener,
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800810 public virtual IBinder::DeathRecipient,
811 public virtual IServiceManager::LocalRegistrationCallback {
Michael Grooverd1d435a2018-12-18 17:39:42 -0800812 public:
813 explicit SensorPrivacyPolicy(wp<CameraService> service)
Evan Severson671806e2021-04-20 16:44:53 -0700814 : mService(service), mSensorPrivacyEnabled(false), mRegistered(false) {}
Michael Grooverd1d435a2018-12-18 17:39:42 -0800815
816 void registerSelf();
817 void unregisterSelf();
818
819 bool isSensorPrivacyEnabled();
Evan Seversond0b69922022-01-27 10:47:34 -0800820 bool isCameraPrivacyEnabled();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800821
Evan Seversond0b69922022-01-27 10:47:34 -0800822 binder::Status onSensorPrivacyChanged(int toggleType, int sensor,
823 bool enabled);
Michael Grooverd1d435a2018-12-18 17:39:42 -0800824
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800825 // Implementation of IServiceManager::LocalRegistrationCallback
826 virtual void onServiceRegistration(const String16& name,
827 const sp<IBinder>& binder) override;
Michael Grooverd1d435a2018-12-18 17:39:42 -0800828 // IBinder::DeathRecipient implementation
829 virtual void binderDied(const wp<IBinder> &who);
830
831 private:
Steven Moreland3cf67172020-01-29 11:44:22 -0800832 SensorPrivacyManager mSpm;
Michael Grooverd1d435a2018-12-18 17:39:42 -0800833 wp<CameraService> mService;
834 Mutex mSensorPrivacyLock;
835 bool mSensorPrivacyEnabled;
836 bool mRegistered;
Evan Severson09ab4002021-02-10 14:15:19 -0800837
838 bool hasCameraPrivacyFeature();
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800839 void registerWithSensorPrivacyManager();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800840 };
841
Svet Ganova453d0d2018-01-11 15:37:58 -0800842 sp<UidPolicy> mUidPolicy;
843
Michael Grooverd1d435a2018-12-18 17:39:42 -0800844 sp<SensorPrivacyPolicy> mSensorPrivacyPolicy;
845
Austin Borger74fca042022-05-23 12:41:21 -0700846 std::shared_ptr<CameraServiceProxyWrapper> mCameraServiceProxyWrapper;
847
Igor Murashkin634a5152013-02-20 17:15:11 -0800848 // Delay-load the Camera HAL module
849 virtual void onFirstRef();
850
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800851 // Eumerate all camera providers in the system
852 status_t enumerateProviders();
853
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800854 // Add/remove a new camera to camera and torch state lists or remove an unplugged one
855 // Caller must not hold mServiceLock
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100856 void addStates(const String8 id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100857 void removeStates(const String8 id);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100858
Ruben Brunkcc776712015-02-17 20:18:47 -0800859 // Check if we can connect, before we acquire the service lock.
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700860 // The returned originalClientPid is the PID of the original process that wants to connect to
861 // camera.
862 // The returned clientPid is the PID of the client that directly connects to camera.
863 // originalClientPid and clientPid are usually the same except when the application uses
864 // mediaserver to connect to camera (using MediaRecorder to connect to camera). In that case,
865 // clientPid is the PID of mediaserver and originalClientPid is the PID of the application.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800866 binder::Status validateConnectLocked(const String8& cameraId, const String8& clientName8,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700867 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const;
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800868 binder::Status validateClientPermissionsLocked(const String8& cameraId, const String8& clientName8,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700869 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800870
Ruben Brunkcc776712015-02-17 20:18:47 -0800871 // Handle active client evictions, and update service state.
872 // Only call with with mServiceLock held.
873 status_t handleEvictionsLocked(const String8& cameraId, int clientPid,
874 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800875 int scoreOffset, bool systemNativeClient,
Ruben Brunkcc776712015-02-17 20:18:47 -0800876 /*out*/
877 sp<BasicClient>* client,
878 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800879
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700880 // Should an operation attempt on a cameraId be rejected ? (this can happen
881 // under various conditions. For example if a camera device is advertised as
882 // system only or hidden secure camera, amongst possible others.
883 bool shouldRejectSystemCameraConnection(const String8 & cameraId) const;
884
885 // Should a device status update be skipped for a particular camera device ? (this can happen
886 // under various conditions. For example if a camera device is advertised as
887 // system only or hidden secure camera, amongst possible others.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700888 static bool shouldSkipStatusUpdates(SystemCameraKind systemCameraKind, bool isVendorListener,
889 int clientPid, int clientUid);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700890
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700891 // Gets the kind of camera device (i.e public, hidden secure or system only)
892 // getSystemCameraKind() needs mInterfaceMutex which might lead to deadlocks
893 // if held along with mStatusListenerLock (depending on lock ordering, b/141756275), it is
894 // recommended that we don't call this function with mStatusListenerLock held.
895 status_t getSystemCameraKind(const String8& cameraId, SystemCameraKind *kind) const;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800896
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700897 // Update the set of API1Compatible camera devices without including system
898 // cameras and secure cameras. This is used for hiding system only cameras
899 // from clients using camera1 api and not having android.permission.SYSTEM_CAMERA.
900 // This function expects @param normalDeviceIds, to have normalDeviceIds
901 // sorted in alpha-numeric order.
902 void filterAPI1SystemCameraLocked(const std::vector<std::string> &normalDeviceIds);
903
Eino-Ville Talvala58106af2022-09-23 16:51:06 -0700904 // In some cases the calling code has no access to the package it runs under.
905 // For example, NDK camera API.
906 // In this case we will get the packages for the calling UID and pick the first one
907 // for attributing the app op. This will work correctly for runtime permissions
908 // as for legacy apps we will toggle the app op for all packages in the UID.
909 // The caveat is that the operation may be attributed to the wrong package and
910 // stats based on app ops may be slightly off.
911 String16 getPackageNameFromUid(int clientUid);
912
Ruben Brunkcc776712015-02-17 20:18:47 -0800913 // Single implementation shared between the various connect calls
914 template<class CALLBACK, class CLIENT>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800915 binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
Eino-Ville Talvala58106af2022-09-23 16:51:06 -0700916 int api1CameraId, const String16& clientPackageNameMaybe, bool systemNativeClient,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900917 const std::optional<String16>& clientFeatureId, int clientUid, int clientPid,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700918 apiLevel effectiveApiLevel, bool shimUpdateOnly, int scoreOffset, int targetSdkVersion,
Chengfei Taobe683db2023-01-31 18:52:49 +0000919 bool overrideToPortrait, bool forceSlowJpegMode,
920 /*out*/sp<CLIENT>& device);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800921
Ruben Brunkcc776712015-02-17 20:18:47 -0800922 // Lock guarding camera service state
Mathias Agopian65ab4712010-07-14 17:59:35 -0700923 Mutex mServiceLock;
Ruben Brunkcc776712015-02-17 20:18:47 -0800924
925 // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients
926 std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper;
927
928 // Return NO_ERROR if the device with a give ID can be connected to
929 status_t checkIfDeviceIsUsable(const String8& cameraId) const;
930
931 // Container for managing currently active application-layer clients
932 CameraClientManager mActiveClientManager;
933
Rucha Katakwardf223072021-06-15 10:21:00 -0700934 // Adds client logs during open session to the file pointed by fd.
935 void dumpOpenSessionClientLogs(int fd, const Vector<String16>& args, const String8& cameraId);
936
937 // Adds client logs during closed session to the file pointed by fd.
938 void dumpClosedSessionClientLogs(int fd, const String8& cameraId);
939
Ruben Brunkcc776712015-02-17 20:18:47 -0800940 // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock
941 std::map<String8, std::shared_ptr<CameraState>> mCameraStates;
942
943 // Mutex guarding mCameraStates map
944 mutable Mutex mCameraStatesLock;
945
946 // Circular buffer for storing event logging for dumps
947 RingBuffer<String8> mEventLog;
Ruben Brunka8ca9152015-04-07 14:23:40 -0700948 Mutex mLogLock;
Ruben Brunkcc776712015-02-17 20:18:47 -0800949
Avichal Rakesh7fbc3982021-10-20 04:35:03 -0700950 // set of client package names to watch. if this set contains 'all', then all clients will
951 // be watched. Access should be guarded by mLogLock
952 std::set<String16> mWatchedClientPackages;
953 // cache of last monitored tags dump immediately before the client disconnects. If a client
954 // re-connects, its entry is not updated until it disconnects again. Access should be guarded
955 // by mLogLock
956 std::map<String16, std::string> mWatchedClientsDumpCache;
957
Emilian Peevbd8c5032018-02-14 23:05:40 +0000958 // The last monitored tags set by client
959 String8 mMonitorTags;
960
Ruben Brunk6267b532015-04-30 17:44:07 -0700961 // Currently allowed user IDs
962 std::set<userid_t> mAllowedUsers;
Ruben Brunk36597b22015-03-20 22:15:57 -0700963
Ruben Brunkcc776712015-02-17 20:18:47 -0800964 /**
965 * Get the camera state for a given camera id.
966 *
967 * This acquires mCameraStatesLock.
968 */
969 std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const;
970
971 /**
972 * Evict client who's remote binder has died. Returns true if this client was in the active
973 * list and was disconnected.
974 *
975 * This method acquires mServiceLock.
976 */
977 bool evictClientIdByRemote(const wp<IBinder>& cameraClient);
978
979 /**
980 * Remove the given client from the active clients list; does not disconnect the client.
981 *
982 * This method acquires mServiceLock.
983 */
984 void removeByClient(const BasicClient* client);
985
986 /**
987 * Add new client to active clients list after conflicting clients have disconnected using the
988 * values set in the partial descriptor passed in to construct the actual client descriptor.
989 * This is typically called at the end of a connect call.
990 *
991 * This method must be called with mServiceLock held.
992 */
Jayant Chowdhary8eb8d912021-05-18 17:41:56 +0000993 void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800994 int oomScoreOffset, bool systemNativeClient);
Ruben Brunkcc776712015-02-17 20:18:47 -0800995
996 /**
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800997 * Returns the underlying camera Id string mapped to a camera id int
998 * Empty string is returned when the cameraIdInt is invalid.
Ruben Brunkcc776712015-02-17 20:18:47 -0800999 */
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001000 String8 cameraIdIntToStr(int cameraIdInt);
1001
1002 /**
1003 * Returns the underlying camera Id string mapped to a camera id int
1004 * Empty string is returned when the cameraIdInt is invalid.
1005 */
1006 std::string cameraIdIntToStrLocked(int cameraIdInt);
Ruben Brunkcc776712015-02-17 20:18:47 -08001007
1008 /**
1009 * Remove a single client corresponding to the given camera id from the list of active clients.
1010 * If none exists, return an empty strongpointer.
1011 *
1012 * This method must be called with mServiceLock held.
1013 */
1014 sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId);
1015
1016 /**
Ruben Brunk36597b22015-03-20 22:15:57 -07001017 * Handle a notification that the current device user has changed.
1018 */
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001019 void doUserSwitch(const std::vector<int32_t>& newUserIds);
Ruben Brunk36597b22015-03-20 22:15:57 -07001020
1021 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001022 * Add an event log message.
Ruben Brunkcc776712015-02-17 20:18:47 -08001023 */
Ruben Brunka8ca9152015-04-07 14:23:40 -07001024 void logEvent(const char* event);
Ruben Brunkcc776712015-02-17 20:18:47 -08001025
1026 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001027 * Add an event log message that a client has been disconnected.
Ruben Brunkcc776712015-02-17 20:18:47 -08001028 */
Ruben Brunka8ca9152015-04-07 14:23:40 -07001029 void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage);
1030
1031 /**
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001032 * Add an event log message that a client has been disconnected from offline device.
1033 */
1034 void logDisconnectedOffline(const char* cameraId, int clientPid, const char* clientPackage);
1035
1036 /**
1037 * Add an event log message that an offline client has been connected.
1038 */
1039 void logConnectedOffline(const char* cameraId, int clientPid,
1040 const char* clientPackage);
1041
1042 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001043 * Add an event log message that a client has been connected.
1044 */
1045 void logConnected(const char* cameraId, int clientPid, const char* clientPackage);
1046
1047 /**
1048 * Add an event log message that a client's connect attempt has been rejected.
1049 */
1050 void logRejected(const char* cameraId, int clientPid, const char* clientPackage,
1051 const char* reason);
1052
1053 /**
Jayant Chowdhary0e2eefd2019-04-18 14:05:43 -07001054 * Add an event log message when a client calls setTorchMode succesfully.
1055 */
1056 void logTorchEvent(const char* cameraId, const char *torchState, int clientPid);
1057
1058 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001059 * Add an event log message that the current device user has been switched.
1060 */
Ruben Brunk6267b532015-04-30 17:44:07 -07001061 void logUserSwitch(const std::set<userid_t>& oldUserIds,
1062 const std::set<userid_t>& newUserIds);
Ruben Brunka8ca9152015-04-07 14:23:40 -07001063
1064 /**
1065 * Add an event log message that a device has been removed by the HAL
1066 */
1067 void logDeviceRemoved(const char* cameraId, const char* reason);
1068
1069 /**
1070 * Add an event log message that a device has been added by the HAL
1071 */
1072 void logDeviceAdded(const char* cameraId, const char* reason);
1073
1074 /**
1075 * Add an event log message that a client has unexpectedly died.
1076 */
1077 void logClientDied(int clientPid, const char* reason);
Ruben Brunkcc776712015-02-17 20:18:47 -08001078
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07001079 /**
1080 * Add a event log message that a serious service-level error has occured
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001081 * The errorCode should be one of the Android Errors
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07001082 */
1083 void logServiceError(const char* msg, int errorCode);
1084
1085 /**
1086 * Dump the event log to an FD
1087 */
1088 void dumpEventLog(int fd);
1089
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001090 void cacheClientTagDumpIfNeeded(const char *cameraId, BasicClient *client);
1091
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001092 /**
1093 * This method will acquire mServiceLock
1094 */
1095 void updateCameraNumAndIds();
1096
Shuzhen Wang89db2992021-05-20 13:09:48 -07001097 /**
Shuzhen Wangb38b53f2021-07-15 12:46:09 -07001098 * Filter camera characteristics for S Performance class primary cameras.
1099 * mServiceLock should be locked.
Shuzhen Wang89db2992021-05-20 13:09:48 -07001100 */
Shuzhen Wangb38b53f2021-07-15 12:46:09 -07001101 void filterSPerfClassCharacteristicsLocked();
Shuzhen Wang89db2992021-05-20 13:09:48 -07001102
Rucha Katakwardf223072021-06-15 10:21:00 -07001103 // File descriptor to temp file used for caching previous open
1104 // session dumpsys info.
1105 int mMemFd;
1106
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001107 // Number of camera devices (excluding hidden secure cameras)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001108 int mNumberOfCameras;
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001109 // Number of camera devices (excluding hidden secure cameras and
1110 // system cameras)
1111 int mNumberOfCamerasWithoutSystemCamera;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001112
1113 std::vector<std::string> mNormalDeviceIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001114 std::vector<std::string> mNormalDeviceIdsWithoutSystemCamera;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001115 std::set<std::string> mPerfClassPrimaryCameraIds;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001116
Mathias Agopian65ab4712010-07-14 17:59:35 -07001117 // sounds
Jaekyun Seokef498052018-03-23 13:09:44 +09001118 sp<MediaPlayer> newMediaPlayer(const char *file);
Chih-Chung Changff4f55c2011-10-17 19:03:12 +08001119
Mathias Agopian65ab4712010-07-14 17:59:35 -07001120 Mutex mSoundLock;
1121 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS];
1122 int mSoundRef; // reference count (release all MediaPlayer when 0)
1123
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001124 // Basic flag on whether the camera subsystem is in a usable state
1125 bool mInitialized;
1126
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001127 sp<CameraProviderManager> mCameraProviderManager;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001128
Emilian Peev53722fa2019-02-22 17:47:20 -08001129 class ServiceListener : public virtual IBinder::DeathRecipient {
1130 public:
1131 ServiceListener(sp<CameraService> parent, sp<hardware::ICameraServiceListener> listener,
Shuzhen Wang695044d2020-03-06 09:02:23 -08001132 int uid, int pid, bool isVendorClient, bool openCloseCallbackAllowed)
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001133 : mParent(parent), mListener(listener), mListenerUid(uid), mListenerPid(pid),
Shuzhen Wang695044d2020-03-06 09:02:23 -08001134 mIsVendorListener(isVendorClient),
1135 mOpenCloseCallbackAllowed(openCloseCallbackAllowed) { }
Emilian Peev53722fa2019-02-22 17:47:20 -08001136
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -07001137 status_t initialize(bool isProcessLocalTest) {
1138 if (isProcessLocalTest) {
1139 return OK;
1140 }
Emilian Peev53722fa2019-02-22 17:47:20 -08001141 return IInterface::asBinder(mListener)->linkToDeath(this);
1142 }
1143
Austin Borgere8e2c422022-05-12 13:45:24 -07001144 template<typename... args_t>
1145 void handleBinderStatus(const binder::Status &ret, const char *logOnError,
1146 args_t... args) {
1147 if (!ret.isOk() &&
1148 (ret.exceptionCode() != binder::Status::Exception::EX_TRANSACTION_FAILED
1149 || !mLastTransactFailed)) {
1150 ALOGE(logOnError, args...);
1151 }
1152
1153 // If the transaction failed, the process may have died (or other things, see
1154 // b/28321379). Mute consecutive errors from this listener to avoid log spam.
1155 if (ret.exceptionCode() == binder::Status::Exception::EX_TRANSACTION_FAILED) {
1156 if (!mLastTransactFailed) {
1157 ALOGE("%s: Muting similar errors from listener %d:%d", __FUNCTION__,
1158 mListenerUid, mListenerPid);
1159 }
1160 mLastTransactFailed = true;
1161 } else {
1162 // Reset mLastTransactFailed when binder becomes healthy again.
1163 mLastTransactFailed = false;
1164 }
1165 }
1166
Emilian Peev53722fa2019-02-22 17:47:20 -08001167 virtual void binderDied(const wp<IBinder> &/*who*/) {
1168 auto parent = mParent.promote();
1169 if (parent.get() != nullptr) {
1170 parent->removeListener(mListener);
1171 }
1172 }
1173
1174 int getListenerUid() { return mListenerUid; }
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001175 int getListenerPid() { return mListenerPid; }
Emilian Peev53722fa2019-02-22 17:47:20 -08001176 sp<hardware::ICameraServiceListener> getListener() { return mListener; }
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001177 bool isVendorListener() { return mIsVendorListener; }
Shuzhen Wang695044d2020-03-06 09:02:23 -08001178 bool isOpenCloseCallbackAllowed() { return mOpenCloseCallbackAllowed; }
Emilian Peev53722fa2019-02-22 17:47:20 -08001179
1180 private:
1181 wp<CameraService> mParent;
1182 sp<hardware::ICameraServiceListener> mListener;
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001183 int mListenerUid = -1;
1184 int mListenerPid = -1;
1185 bool mIsVendorListener = false;
Shuzhen Wang695044d2020-03-06 09:02:23 -08001186 bool mOpenCloseCallbackAllowed = false;
Austin Borgere8e2c422022-05-12 13:45:24 -07001187
1188 // Flag for preventing log spam when binder becomes unhealthy
1189 bool mLastTransactFailed = false;
Emilian Peev53722fa2019-02-22 17:47:20 -08001190 };
1191
Ruben Brunkcc776712015-02-17 20:18:47 -08001192 // Guarded by mStatusListenerMutex
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001193 std::vector<sp<ServiceListener>> mListenerList;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001194
Ruben Brunkcc776712015-02-17 20:18:47 -08001195 Mutex mStatusListenerLock;
Igor Murashkinbfc99152013-02-27 12:55:20 -08001196
Ruben Brunkcc776712015-02-17 20:18:47 -08001197 /**
1198 * Update the status for the given camera id (if that device exists), and broadcast the
1199 * status update to all current ICameraServiceListeners if the status has changed. Any
1200 * statuses in rejectedSourceStates will be ignored.
1201 *
1202 * This method must be idempotent.
1203 * This method acquires mStatusLock and mStatusListenerLock.
1204 */
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001205 void updateStatus(StatusInternal status,
1206 const String8& cameraId,
1207 std::initializer_list<StatusInternal>
1208 rejectedSourceStates);
1209 void updateStatus(StatusInternal status,
1210 const String8& cameraId);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001211
Shuzhen Wang695044d2020-03-06 09:02:23 -08001212 /**
1213 * Update the opened/closed status of the given camera id.
1214 *
1215 * This method acqiures mStatusListenerLock.
1216 */
1217 void updateOpenCloseStatus(const String8& cameraId, bool open, const String16& packageName);
1218
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001219 // flashlight control
1220 sp<CameraFlashlight> mFlashlight;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001221 // guard mTorchStatusMap
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001222 Mutex mTorchStatusMutex;
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001223 // guard mTorchClientMap
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001224 Mutex mTorchClientMapMutex;
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001225 // guard mTorchUidMap
1226 Mutex mTorchUidMapMutex;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001227 // camera id -> torch status
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001228 KeyedVector<String8, TorchModeStatus>
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001229 mTorchStatusMap;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001230 // camera id -> torch client binder
1231 // only store the last client that turns on each camera's torch mode
Ruben Brunk99e69712015-05-26 17:25:07 -07001232 KeyedVector<String8, sp<IBinder>> mTorchClientMap;
1233 // camera id -> [incoming uid, current uid] pair
1234 std::map<String8, std::pair<int, int>> mTorchUidMap;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001235
1236 // check and handle if torch client's process has died
1237 void handleTorchClientBinderDied(const wp<IBinder> &who);
1238
1239 // handle torch mode status change and invoke callbacks. mTorchStatusMutex
1240 // should be locked.
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001241 void onTorchStatusChangedLocked(const String8& cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001242 TorchModeStatus newStatus,
Jayant Chowdhary8c62d892021-03-31 02:13:46 -07001243 SystemCameraKind systemCameraKind);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001244
1245 // get a camera's torch status. mTorchStatusMutex should be locked.
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001246 status_t getTorchStatusLocked(const String8 &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001247 TorchModeStatus *status) const;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001248
1249 // set a camera's torch status. mTorchStatusMutex should be locked.
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001250 status_t setTorchStatusLocked(const String8 &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001251 TorchModeStatus status);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001252
Shuzhen Wang43858162020-01-10 13:42:15 -08001253 // notify physical camera status when the physical camera is public.
Jayant Chowdhary5e2cd302020-08-14 02:48:34 +00001254 // Expects mStatusListenerLock to be locked.
1255 void notifyPhysicalCameraStatusLocked(int32_t status, const String16& physicalCameraId,
1256 const std::list<String16>& logicalCameraIds, SystemCameraKind deviceKind);
1257
1258 // get list of logical cameras which are backed by physicalCameraId
1259 std::list<String16> getLogicalCameras(const String8& physicalCameraId);
1260
Shuzhen Wang43858162020-01-10 13:42:15 -08001261
Igor Murashkinecf17e82012-10-02 16:05:11 -07001262 // IBinder::DeathRecipient implementation
Igor Murashkinbfc99152013-02-27 12:55:20 -08001263 virtual void binderDied(const wp<IBinder> &who);
Igor Murashkin634a5152013-02-20 17:15:11 -08001264
Ruben Brunkb2119af2014-05-09 19:57:56 -07001265 /**
Ruben Brunkb2119af2014-05-09 19:57:56 -07001266 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId.
1267 *
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001268 * Sets Status to a service-specific error on failure
Ruben Brunkb2119af2014-05-09 19:57:56 -07001269 */
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001270 binder::Status initializeShimMetadata(int cameraId);
Ruben Brunkb2119af2014-05-09 19:57:56 -07001271
1272 /**
Igor Murashkin65d14b92014-06-17 12:03:20 -07001273 * Get the cached CameraParameters for the camera. If they haven't been
1274 * cached yet, then initialize them for the first time.
1275 *
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001276 * Sets Status to a service-specific error on failure
Igor Murashkin65d14b92014-06-17 12:03:20 -07001277 */
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001278 binder::Status getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters);
Igor Murashkin65d14b92014-06-17 12:03:20 -07001279
Svet Ganova453d0d2018-01-11 15:37:58 -08001280 // Blocks all clients from the UID
1281 void blockClientsForUid(uid_t uid);
1282
Michael Grooverd1d435a2018-12-18 17:39:42 -08001283 // Blocks all active clients.
1284 void blockAllClients();
1285
Svet Ganova453d0d2018-01-11 15:37:58 -08001286 // Overrides the UID state as if it is idle
1287 status_t handleSetUidState(const Vector<String16>& args, int err);
1288
1289 // Clears the override for the UID state
1290 status_t handleResetUidState(const Vector<String16>& args, int err);
1291
1292 // Gets the UID state
1293 status_t handleGetUidState(const Vector<String16>& args, int out, int err);
1294
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001295 // Set the rotate-and-crop AUTO override behavior
1296 status_t handleSetRotateAndCrop(const Vector<String16>& args);
1297
1298 // Get the rotate-and-crop AUTO override behavior
1299 status_t handleGetRotateAndCrop(int out);
1300
Bharatt Kukreja7146ced2022-10-25 15:45:29 +00001301 // Set the autoframing AUTO override behaviour.
1302 status_t handleSetAutoframing(const Vector<String16>& args);
1303
1304 // Get the autoframing AUTO override behaviour
1305 status_t handleGetAutoframing(int out);
1306
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001307 // Set the mask for image dump to disk
1308 status_t handleSetImageDumpMask(const Vector<String16>& args);
1309
1310 // Get the mask for image dump to disk
1311 status_t handleGetImageDumpMask(int out);
1312
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001313 // Set the camera mute state
1314 status_t handleSetCameraMute(const Vector<String16>& args);
1315
Shuzhen Wang16610a62022-12-15 22:38:07 -08001316 // Set the stream use case overrides
1317 status_t handleSetStreamUseCaseOverrides(const Vector<String16>& args);
1318
1319 // Clear the stream use case overrides
1320 void handleClearStreamUseCaseOverrides();
1321
Shuzhen Wangaf22e912023-04-11 16:03:17 -07001322 // Set or clear the zoom override flag
1323 status_t handleSetZoomOverride(const Vector<String16>& args);
1324
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001325 // Handle 'watch' command as passed through 'cmd'
Avichal Rakesh84147132021-11-11 17:47:11 -08001326 status_t handleWatchCommand(const Vector<String16> &args, int inFd, int outFd);
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001327
Ravneetaeb20dc2022-03-30 05:33:03 +00001328 // Set the camera service watchdog
1329 status_t handleSetCameraServiceWatchdog(const Vector<String16>& args);
1330
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001331 // Enable tag monitoring of the given tags in provided clients
1332 status_t startWatchingTags(const Vector<String16> &args, int outFd);
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001333
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001334 // Disable tag monitoring
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001335 status_t stopWatchingTags(int outFd);
1336
Avichal Rakesh3a85d2d2021-11-10 16:21:33 -08001337 // Clears mWatchedClientsDumpCache
1338 status_t clearCachedMonitoredTagDumps(int outFd);
1339
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001340 // Print events of monitored tags in all cached and attached clients
Avichal Rakesh9e5a1e42021-11-15 12:11:21 -08001341 status_t printWatchedTags(int outFd);
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001342
1343 // Print events of monitored tags in all attached clients as they are captured. New events are
Avichal Rakesh84147132021-11-11 17:47:11 -08001344 // fetched every `refreshMillis` ms
1345 // NOTE: This function does not terminate until user passes '\n' to inFd.
Avichal Rakesh9e5a1e42021-11-15 12:11:21 -08001346 status_t printWatchedTagsUntilInterrupt(const Vector<String16> &args, int inFd, int outFd);
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001347
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001348 // Parses comma separated clients list and adds them to mWatchedClientPackages.
1349 // Does not acquire mLogLock before modifying mWatchedClientPackages. It is the caller's
1350 // responsibility to acquire mLogLock before calling this function.
1351 void parseClientsToWatchLocked(String8 clients);
1352
Svet Ganova453d0d2018-01-11 15:37:58 -08001353 // Prints the shell command help
1354 status_t printHelp(int out);
1355
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001356 // Returns true if client should monitor tags based on the contents of mWatchedClientPackages.
1357 // Acquires mLogLock before querying mWatchedClientPackages.
1358 bool isClientWatched(const BasicClient *client);
1359
1360 // Returns true if client should monitor tags based on the contents of mWatchedClientPackages.
1361 // Does not acquire mLogLock before querying mWatchedClientPackages. It is the caller's
1362 // responsibility to acquire mLogLock before calling this functions.
1363 bool isClientWatchedLocked(const BasicClient *client);
1364
Ruben Brunkb2119af2014-05-09 19:57:56 -07001365 /**
Ruben Brunkcc776712015-02-17 20:18:47 -08001366 * Get the current system time as a formatted string.
Ruben Brunkb2119af2014-05-09 19:57:56 -07001367 */
Ruben Brunkcc776712015-02-17 20:18:47 -08001368 static String8 getFormattedCurrentTime();
1369
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001370 static binder::Status makeClient(const sp<CameraService>& cameraService,
Philip P. Moltmann9e648f62019-11-04 12:52:45 -08001371 const sp<IInterface>& cameraCb, const String16& packageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -08001372 bool systemNativeClient, const std::optional<String16>& featureId,
1373 const String8& cameraId, int api1CameraId, int facing, int sensorOrientation,
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001374 int clientPid, uid_t clientUid, int servicePid,
1375 std::pair<int, IPCTransport> deviceVersionAndIPCTransport, apiLevel effectiveApiLevel,
Chengfei Taobe683db2023-01-31 18:52:49 +00001376 bool overrideForPerfClass, bool overrideToPortrait, bool forceSlowJpegMode,
1377 /*out*/sp<BasicClient>* client);
Ruben Brunk6267b532015-04-30 17:44:07 -07001378
1379 status_t checkCameraAccess(const String16& opPackageName);
1380
1381 static String8 toString(std::set<userid_t> intSet);
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001382 static int32_t mapToInterface(TorchModeStatus status);
1383 static StatusInternal mapToInternal(CameraDeviceStatus status);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001384 static int32_t mapToInterface(StatusInternal status);
Ruben Brunk6267b532015-04-30 17:44:07 -07001385
Ruben Brunk2823ce02015-05-19 17:25:13 -07001386
Shuzhen Wang7d859d42018-11-06 15:33:23 -08001387 void broadcastTorchModeStatus(const String8& cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001388 TorchModeStatus status, SystemCameraKind systemCameraKind);
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001389
Rucha Katakwar38284522021-11-10 11:25:21 -08001390 void broadcastTorchStrengthLevel(const String8& cameraId, int32_t newTorchStrengthLevel);
1391
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001392 void disconnectClient(const String8& id, sp<BasicClient> clientToDisconnect);
1393
1394 // Regular online and offline devices must not be in conflict at camera service layer.
1395 // Use separate keys for offline devices.
1396 static const String8 kOfflineDevice;
1397
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001398 // Sentinel value to be stored in `mWatchedClientsPackages` to indicate that all clients should
1399 // be watched.
1400 static const String16 kWatchAllClientsFlag;
1401
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001402 // TODO: right now each BasicClient holds one AppOpsManager instance.
1403 // We can refactor the code so all of clients share this instance
1404 AppOpsManager mAppOps;
1405
1406 // Aggreated audio restriction mode for all camera clients
1407 int32_t mAudioRestriction;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001408
Emilian Peev8b64f282021-03-25 16:49:57 -07001409 // Current override cmd rotate-and-crop mode; AUTO means no override
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001410 uint8_t mOverrideRotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_AUTO;
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001411
Bharatt Kukreja7146ced2022-10-25 15:45:29 +00001412 // Current autoframing mode
1413 uint8_t mOverrideAutoframingMode = ANDROID_CONTROL_AUTOFRAMING_AUTO;
1414
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001415 // Current image dump mask
1416 uint8_t mImageDumpMask = 0;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001417
1418 // Current camera mute mode
1419 bool mOverrideCameraMuteMode = false;
Cliff Wud8cae102021-03-11 01:37:42 +08001420
Ravneetaeb20dc2022-03-30 05:33:03 +00001421 // Camera Service watchdog flag
1422 bool mCameraServiceWatchdogEnabled = true;
1423
Shuzhen Wang16610a62022-12-15 22:38:07 -08001424 // Current stream use case overrides
1425 std::vector<int64_t> mStreamUseCaseOverrides;
1426
Shuzhen Wangaf22e912023-04-11 16:03:17 -07001427 // Current zoom override value
1428 int32_t mZoomOverrideValue = -1;
1429
Cliff Wud8cae102021-03-11 01:37:42 +08001430 /**
1431 * A listener class that implements the IBinder::DeathRecipient interface
1432 * for use to call back the error state injected by the external camera, and
1433 * camera service can kill the injection when binder signals process death.
1434 */
1435 class InjectionStatusListener : public virtual IBinder::DeathRecipient {
1436 public:
1437 InjectionStatusListener(sp<CameraService> parent) : mParent(parent) {}
1438
1439 void addListener(const sp<hardware::camera2::ICameraInjectionCallback>& callback);
1440 void removeListener();
Cliff Wud3a05312021-04-26 23:07:31 +08001441 void notifyInjectionError(String8 injectedCamId, status_t err);
Cliff Wud8cae102021-03-11 01:37:42 +08001442
1443 // IBinder::DeathRecipient implementation
1444 virtual void binderDied(const wp<IBinder>& who);
1445
1446 private:
1447 Mutex mListenerLock;
1448 wp<CameraService> mParent;
1449 sp<hardware::camera2::ICameraInjectionCallback> mCameraInjectionCallback;
1450 };
1451
1452 sp<InjectionStatusListener> mInjectionStatusListener;
1453
1454 /**
1455 * A class that implements the hardware::camera2::BnCameraInjectionSession interface
1456 */
1457 class CameraInjectionSession : public hardware::camera2::BnCameraInjectionSession {
1458 public:
1459 CameraInjectionSession(sp<CameraService> parent) : mParent(parent) {}
1460 virtual ~CameraInjectionSession() {}
1461 binder::Status stopInjection() override;
1462
1463 private:
1464 Mutex mInjectionSessionLock;
1465 wp<CameraService> mParent;
1466 };
1467
Cliff Wu646bd612021-11-23 23:21:29 +08001468 // When injecting the camera, it will check whether the injecting camera status is unavailable.
1469 // If it is, the disconnect function will be called to to prevent camera access on the device.
1470 status_t checkIfInjectionCameraIsPresent(const String8& externalCamId,
1471 sp<BasicClient> clientSp);
1472
Cliff Wud3a05312021-04-26 23:07:31 +08001473 void clearInjectionParameters();
1474
1475 // This is the existing camera id being replaced.
1476 String8 mInjectionInternalCamId;
1477 // This is the external camera Id replacing the internalId.
1478 String8 mInjectionExternalCamId;
Cliff Wu646bd612021-11-23 23:21:29 +08001479 bool mInjectionInitPending = false;
Cliff Wud3a05312021-04-26 23:07:31 +08001480 // Guard mInjectionInternalCamId and mInjectionInitPending.
1481 Mutex mInjectionParametersLock;
Rucha Katakwar38284522021-11-10 11:25:21 -08001482
Austin Borger18b30a72022-10-27 12:20:29 -07001483 // Track the folded/unfoled device state. 0 == UNFOLDED, 4 == FOLDED
1484 int64_t mDeviceState;
1485
Rucha Katakwar38284522021-11-10 11:25:21 -08001486 void updateTorchUidMapLocked(const String16& cameraId, int uid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001487};
1488
Mathias Agopian65ab4712010-07-14 17:59:35 -07001489} // namespace android
1490
1491#endif