blob: d84cb00e049b3c50a171484e5f9cf3c66e224af6 [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
Igor Murashkin634a5152013-02-20 17:15:11 -0800221 // Extra permissions checks
Mathias Agopian65ab4712010-07-14 17:59:35 -0700222 virtual status_t onTransact(uint32_t code, const Parcel& data,
223 Parcel* reply, uint32_t flags);
Igor Murashkin634a5152013-02-20 17:15:11 -0800224
225 virtual status_t dump(int fd, const Vector<String16>& args);
226
Svet Ganova453d0d2018-01-11 15:37:58 -0800227 virtual status_t shellCommand(int in, int out, int err, const Vector<String16>& args);
228
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800229 binder::Status addListenerHelper(const sp<hardware::ICameraServiceListener>& listener,
230 /*out*/
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -0700231 std::vector<hardware::CameraStatus>* cameraStatuses, bool isVendor = false,
232 bool isProcessLocalTest = false);
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800233
Emilian Peev53722fa2019-02-22 17:47:20 -0800234 // Monitored UIDs availability notification
235 void notifyMonitoredUids();
Austin Borgerdddb7552023-03-30 17:53:01 -0700236 void notifyMonitoredUids(const std::unordered_set<uid_t> &notifyUidSet);
Emilian Peev53722fa2019-02-22 17:47:20 -0800237
Rucha Katakwardf223072021-06-15 10:21:00 -0700238 // Stores current open session device info in temp file.
239 void cacheDump();
240
Emilian Peevb2bc5a42019-11-20 16:02:14 -0800241 // Register an offline client for a given active camera id
242 status_t addOfflineClient(String8 cameraId, sp<BasicClient> offlineClient);
243
Igor Murashkin634a5152013-02-20 17:15:11 -0800244 /////////////////////////////////////////////////////////////////////
245 // Client functionality
Mathias Agopian65ab4712010-07-14 17:59:35 -0700246
247 enum sound_kind {
248 SOUND_SHUTTER = 0,
Chien-Yu Chen82104eb2015-10-14 11:29:31 -0700249 SOUND_RECORDING_START = 1,
250 SOUND_RECORDING_STOP = 2,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700251 NUM_SOUNDS
252 };
253
Mathias Agopian65ab4712010-07-14 17:59:35 -0700254 void playSound(sound_kind kind);
username5755fea2018-12-27 09:48:08 +0800255 void loadSoundLocked(sound_kind kind);
256 void decreaseSoundRef();
257 void increaseSoundRef();
Eino-Ville Talvala412fe562015-08-20 17:08:32 -0700258
Igor Murashkin98e24722013-06-19 19:51:04 -0700259 /////////////////////////////////////////////////////////////////////
260 // CameraDeviceFactory functionality
Austin Borger18b30a72022-10-27 12:20:29 -0700261 std::pair<int, IPCTransport> getDeviceVersion(const String8& cameraId,
262 bool overrideToPortrait, int* portraitRotation,
263 int* facing = nullptr, int* orientation = nullptr);
Igor Murashkin98e24722013-06-19 19:51:04 -0700264
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700265 /////////////////////////////////////////////////////////////////////
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -0700266 // Methods to be used in CameraService class tests only
267 //
268 // CameraService class test method only - clear static variables in the
269 // cameraserver process, which otherwise might affect multiple test runs.
270 void clearCachedVariables();
271
272 // Add test listener, linkToDeath won't be called since this is for process
273 // local testing.
274 binder::Status addListenerTest(const sp<hardware::ICameraServiceListener>& listener,
275 /*out*/
276 std::vector<hardware::CameraStatus>* cameraStatuses);
277
278 /////////////////////////////////////////////////////////////////////
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700279 // Shared utilities
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800280 static binder::Status filterGetInfoErrorCode(status_t err);
Igor Murashkin634a5152013-02-20 17:15:11 -0800281
282 /////////////////////////////////////////////////////////////////////
283 // CameraClient functionality
284
Igor Murashkin634a5152013-02-20 17:15:11 -0800285 class BasicClient : public virtual RefBase {
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -0700286 friend class CameraService;
Igor Murashkin634a5152013-02-20 17:15:11 -0800287 public:
Emilian Peevbd8c5032018-02-14 23:05:40 +0000288 virtual status_t initialize(sp<CameraProviderManager> manager,
289 const String8& monitorTags) = 0;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800290 virtual binder::Status disconnect();
Igor Murashkin634a5152013-02-20 17:15:11 -0800291
Igor Murashkine7ee7632013-06-11 18:10:18 -0700292 // because we can't virtually inherit IInterface, which breaks
293 // virtual inheritance
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800294 virtual sp<IBinder> asBinderWrapper() = 0;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700295
Ruben Brunk9efdf952015-03-18 23:11:57 -0700296 // Return the remote callback binder object (e.g. ICameraDeviceCallbacks)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800297 sp<IBinder> getRemote() {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800298 return mRemoteBinder;
Igor Murashkin634a5152013-02-20 17:15:11 -0800299 }
300
Austin Borger18b30a72022-10-27 12:20:29 -0700301 bool getOverrideToPortrait() const {
302 return mOverrideToPortrait;
303 }
304
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800305 // Disallows dumping over binder interface
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800306 virtual status_t dump(int fd, const Vector<String16>& args);
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800307 // Internal dump method to be called by CameraService
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800308 virtual status_t dumpClient(int fd, const Vector<String16>& args) = 0;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700309
Avichal Rakesh7e53cad2021-10-05 13:46:30 -0700310 virtual status_t startWatchingTags(const String8 &tags, int outFd);
311 virtual status_t stopWatchingTags(int outFd);
312 virtual status_t dumpWatchedEventsToVector(std::vector<std::string> &out);
313
Ruben Brunkcc776712015-02-17 20:18:47 -0800314 // Return the package name for this client
315 virtual String16 getPackageName() const;
316
Emilian Peev8b64f282021-03-25 16:49:57 -0700317 // Return the camera facing for this client
318 virtual int getCameraFacing() const;
319
320 // Return the camera orientation for this client
321 virtual int getCameraOrientation() const;
322
Ruben Brunkcc776712015-02-17 20:18:47 -0800323 // Notify client about a fatal error
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800324 virtual void notifyError(int32_t errorCode,
Ruben Brunkcc776712015-02-17 20:18:47 -0800325 const CaptureResultExtras& resultExtras) = 0;
326
Ruben Brunk6267b532015-04-30 17:44:07 -0700327 // Get the UID of the application client using this
328 virtual uid_t getClientUid() const;
329
Ruben Brunkcc776712015-02-17 20:18:47 -0800330 // Get the PID of the application client using this
331 virtual int getClientPid() const;
Ruben Brunk0bbf8b22015-04-30 14:35:42 -0700332
333 // Check what API level is used for this client. This is used to determine which
334 // superclass this can be cast to.
335 virtual bool canCastToApiClient(apiLevel level) const;
Svet Ganova453d0d2018-01-11 15:37:58 -0800336
337 // Block the client form using the camera
338 virtual void block();
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700339
340 // set audio restriction from client
341 // Will call into camera service and hold mServiceLock
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -0700342 virtual status_t setAudioRestriction(int32_t mode);
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700343
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -0700344 // Get current global audio restriction setting
345 // Will call into camera service and hold mServiceLock
346 virtual int32_t getServiceAudioRestriction() const;
347
348 // Get current audio restriction setting for this client
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700349 virtual int32_t getAudioRestriction() const;
350
351 static bool isValidAudioRestriction(int32_t mode);
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800352
353 // Override rotate-and-crop AUTO behavior
354 virtual status_t setRotateAndCropOverride(uint8_t rotateAndCrop) = 0;
355
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000356 // Override autoframing AUTO behaviour
357 virtual status_t setAutoframingOverride(uint8_t autoframingValue) = 0;
358
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800359 // Whether the client supports camera muting (black only output)
360 virtual bool supportsCameraMute() = 0;
361
362 // Set/reset camera mute
363 virtual status_t setCameraMute(bool enabled) = 0;
364
Ravneetaeb20dc2022-03-30 05:33:03 +0000365 // Set Camera service watchdog
366 virtual status_t setCameraServiceWatchdog(bool enabled) = 0;
367
Shuzhen Wang16610a62022-12-15 22:38:07 -0800368 // Set stream use case overrides
369 virtual void setStreamUseCaseOverrides(
370 const std::vector<int64_t>& useCaseOverrides) = 0;
371
372 // Clear stream use case overrides
373 virtual void clearStreamUseCaseOverrides() = 0;
374
Shuzhen Wangaf22e912023-04-11 16:03:17 -0700375 // Whether the client supports camera zoom override
376 virtual bool supportsZoomOverride() = 0;
377
378 // Set/reset zoom override
379 virtual status_t setZoomOverride(int32_t zoomOverride) = 0;
380
Cliff Wud3a05312021-04-26 23:07:31 +0800381 // The injection camera session to replace the internal camera
382 // session.
383 virtual status_t injectCamera(const String8& injectedCamId,
384 sp<CameraProviderManager> manager) = 0;
385
386 // Stop the injection camera and restore to internal camera session.
387 virtual status_t stopInjection() = 0;
388
Igor Murashkin634a5152013-02-20 17:15:11 -0800389 protected:
390 BasicClient(const sp<CameraService>& cameraService,
391 const sp<IBinder>& remoteCallback,
Svetoslav Ganov280405a2015-05-12 02:19:27 +0000392 const String16& clientPackageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800393 bool nativeClient,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900394 const std::optional<String16>& clientFeatureId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800395 const String8& cameraIdStr,
Igor Murashkin634a5152013-02-20 17:15:11 -0800396 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -0700397 int sensorOrientation,
Igor Murashkin634a5152013-02-20 17:15:11 -0800398 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800399 uid_t clientUid,
Austin Borger18b30a72022-10-27 12:20:29 -0700400 int servicePid,
401 bool overrideToPortrait);
Igor Murashkin634a5152013-02-20 17:15:11 -0800402
403 virtual ~BasicClient();
404
405 // the instance is in the middle of destruction. When this is set,
406 // the instance should not be accessed from callback.
407 // CameraService's mClientLock should be acquired to access this.
408 // - subclasses should set this to true in their destructors.
409 bool mDestructionStarted;
410
411 // these are initialized in the constructor.
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800412 static sp<CameraService> sCameraService;
413 const String8 mCameraIdStr;
414 const int mCameraFacing;
Emilian Peev8b64f282021-03-25 16:49:57 -0700415 const int mOrientation;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800416 String16 mClientPackageName;
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800417 bool mSystemNativeClient;
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900418 std::optional<String16> mClientFeatureId;
Igor Murashkin634a5152013-02-20 17:15:11 -0800419 pid_t mClientPid;
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800420 const uid_t mClientUid;
421 const pid_t mServicePid;
Ruben Brunkcc776712015-02-17 20:18:47 -0800422 bool mDisconnected;
Shuzhen Wang2c656792020-04-13 17:36:49 -0700423 bool mUidIsTrusted;
Austin Borger18b30a72022-10-27 12:20:29 -0700424 bool mOverrideToPortrait;
Igor Murashkin634a5152013-02-20 17:15:11 -0800425
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700426 mutable Mutex mAudioRestrictionLock;
427 int32_t mAudioRestriction;
428
Igor Murashkin634a5152013-02-20 17:15:11 -0800429 // - The app-side Binder interface to receive callbacks from us
Igor Murashkine7ee7632013-06-11 18:10:18 -0700430 sp<IBinder> mRemoteBinder; // immutable after constructor
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800431
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700432 // Permissions management methods for camera lifecycle
433
434 // Notify rest of system/apps about camera opening, and check appops
Emilian Peevb2bc5a42019-11-20 16:02:14 -0800435 virtual status_t startCameraOps();
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700436 // Notify rest of system/apps about camera starting to stream data, and confirm appops
437 virtual status_t startCameraStreamingOps();
438 // Notify rest of system/apps about camera stopping streaming data
439 virtual status_t finishCameraStreamingOps();
440 // Notify rest of system/apps about camera closing
Emilian Peevb2bc5a42019-11-20 16:02:14 -0800441 virtual status_t finishCameraOps();
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700442 // Handle errors for start/checkOps
443 virtual status_t handleAppOpMode(int32_t mode);
Valentin Iftimec0b8d472021-07-23 20:21:06 +0200444 // Just notify camera appops to trigger unblocking dialog if sensor
445 // privacy is enabled and camera mute is not supported
446 virtual status_t noteAppOp();
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800447
Jayant Chowdharyb61526c2019-05-13 19:37:42 -0700448 std::unique_ptr<AppOpsManager> mAppOpsManager = nullptr;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800449
450 class OpsCallback : public BnAppOpsCallback {
451 public:
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700452 explicit OpsCallback(wp<BasicClient> client);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800453 virtual void opChanged(int32_t op, const String16& packageName);
454
455 private:
456 wp<BasicClient> mClient;
457
458 }; // class OpsCallback
459
460 sp<OpsCallback> mOpsCallback;
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700461 // Track whether checkOps was called successfully, to avoid
462 // finishing what we didn't start, on camera open.
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800463 bool mOpsActive;
Eino-Ville Talvala178e8232021-04-16 18:41:39 -0700464 // Track whether startOps was called successfully on start of
465 // camera streaming.
466 bool mOpsStreaming;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800467
468 // IAppOpsCallback interface, indirected through opListener
469 virtual void opChanged(int32_t op, const String16& packageName);
470 }; // class BasicClient
Igor Murashkin634a5152013-02-20 17:15:11 -0800471
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800472 class Client : public hardware::BnCamera, public BasicClient
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700473 {
474 public:
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800475 typedef hardware::ICameraClient TCamCallbacks;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800476
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700477 // ICamera interface (see ICamera for details)
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800478 virtual binder::Status disconnect();
479 virtual status_t connect(const sp<hardware::ICameraClient>& client) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700480 virtual status_t lock() = 0;
481 virtual status_t unlock() = 0;
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700482 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700483 virtual void setPreviewCallbackFlag(int flag) = 0;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700484 virtual status_t setPreviewCallbackTarget(
485 const sp<IGraphicBufferProducer>& callbackProducer) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700486 virtual status_t startPreview() = 0;
487 virtual void stopPreview() = 0;
488 virtual bool previewEnabled() = 0;
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800489 virtual status_t setVideoBufferMode(int32_t videoBufferMode) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700490 virtual status_t startRecording() = 0;
491 virtual void stopRecording() = 0;
492 virtual bool recordingEnabled() = 0;
493 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0;
494 virtual status_t autoFocus() = 0;
495 virtual status_t cancelAutoFocus() = 0;
496 virtual status_t takePicture(int msgType) = 0;
497 virtual status_t setParameters(const String8& params) = 0;
498 virtual String8 getParameters() const = 0;
499 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800500 virtual status_t setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) = 0;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700501
502 // Interface used by CameraService
503 Client(const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800504 const sp<hardware::ICameraClient>& cameraClient,
Svetoslav Ganov280405a2015-05-12 02:19:27 +0000505 const String16& clientPackageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800506 bool systemNativeClient,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900507 const std::optional<String16>& clientFeatureId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800508 const String8& cameraIdStr,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800509 int api1CameraId,
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700510 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -0700511 int sensorOrientation,
Igor Murashkinecf17e82012-10-02 16:05:11 -0700512 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800513 uid_t clientUid,
Austin Borger18b30a72022-10-27 12:20:29 -0700514 int servicePid,
515 bool overrideToPortrait);
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700516 ~Client();
517
518 // return our camera client
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800519 const sp<hardware::ICameraClient>& getRemoteCallback() {
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800520 return mRemoteCallback;
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700521 }
522
Igor Murashkine7ee7632013-06-11 18:10:18 -0700523 virtual sp<IBinder> asBinderWrapper() {
Marco Nelissen06b46062014-11-14 07:58:25 -0800524 return asBinder(this);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700525 }
526
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800527 virtual void notifyError(int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -0700528 const CaptureResultExtras& resultExtras);
Ruben Brunk0bbf8b22015-04-30 14:35:42 -0700529
530 // Check what API level is used for this client. This is used to determine which
531 // superclass this can be cast to.
532 virtual bool canCastToApiClient(apiLevel level) const;
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800533
534 void setImageDumpMask(int /*mask*/) { }
Ruben Brunkcc776712015-02-17 20:18:47 -0800535 protected:
Igor Murashkin634a5152013-02-20 17:15:11 -0800536 // Initialized in constructor
Eino-Ville Talvala5e08d602012-05-16 14:59:25 -0700537
Igor Murashkin634a5152013-02-20 17:15:11 -0800538 // - The app-side Binder interface to receive callbacks from us
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800539 sp<hardware::ICameraClient> mRemoteCallback;
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800540
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800541 int mCameraId; // All API1 clients use integer camera IDs
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800542 }; // class Client
Igor Murashkin634a5152013-02-20 17:15:11 -0800543
Ruben Brunk99e69712015-05-26 17:25:07 -0700544 /**
545 * A listener class that implements the LISTENER interface for use with a ClientManager, and
546 * implements the following methods:
547 * void onClientRemoved(const ClientDescriptor<KEY, VALUE>& descriptor);
548 * void onClientAdded(const ClientDescriptor<KEY, VALUE>& descriptor);
549 */
550 class ClientEventListener {
551 public:
552 void onClientAdded(const resource_policy::ClientDescriptor<String8,
553 sp<CameraService::BasicClient>>& descriptor);
554 void onClientRemoved(const resource_policy::ClientDescriptor<String8,
555 sp<CameraService::BasicClient>>& descriptor);
556 }; // class ClientEventListener
557
Ruben Brunkcc776712015-02-17 20:18:47 -0800558 typedef std::shared_ptr<resource_policy::ClientDescriptor<String8,
559 sp<CameraService::BasicClient>>> DescriptorPtr;
560
561 /**
562 * A container class for managing active camera clients that are using HAL devices. Active
563 * clients are represented by ClientDescriptor objects that contain strong pointers to the
564 * actual BasicClient subclass binder interface implementation.
565 *
566 * This class manages the eviction behavior for the camera clients. See the parent class
567 * implementation in utils/ClientManager for the specifics of this behavior.
568 */
Ruben Brunk99e69712015-05-26 17:25:07 -0700569 class CameraClientManager : public resource_policy::ClientManager<String8,
570 sp<CameraService::BasicClient>, ClientEventListener> {
Ruben Brunkcc776712015-02-17 20:18:47 -0800571 public:
Ruben Brunk99e69712015-05-26 17:25:07 -0700572 CameraClientManager();
Ruben Brunkcc776712015-02-17 20:18:47 -0800573 virtual ~CameraClientManager();
574
575 /**
576 * Return a strong pointer to the active BasicClient for this camera ID, or an empty
577 * if none exists.
578 */
579 sp<CameraService::BasicClient> getCameraClient(const String8& id) const;
580
581 /**
582 * Return a string describing the current state.
583 */
584 String8 toString() const;
585
586 /**
587 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer.
588 */
589 static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value,
Emilian Peev8131a262017-02-01 12:33:43 +0000590 int32_t cost, const std::set<String8>& conflictingKeys, int32_t score,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800591 int32_t ownerId, int32_t state, int oomScoreOffset, bool systemNativeClient);
Ruben Brunkcc776712015-02-17 20:18:47 -0800592
593 /**
594 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with
595 * values intialized from a prior ClientDescriptor.
596 */
597 static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800598 const CameraService::DescriptorPtr& partial, int oomScoreOffset,
599 bool systemNativeClient);
Ruben Brunkcc776712015-02-17 20:18:47 -0800600
601 }; // class CameraClientManager
602
Yin-Chia Yehdba03232019-08-19 15:54:28 -0700603 int32_t updateAudioRestriction();
604 int32_t updateAudioRestrictionLocked();
605
Mathias Agopian65ab4712010-07-14 17:59:35 -0700606private:
Igor Murashkin634a5152013-02-20 17:15:11 -0800607
Kunal Malhotrabfc96052023-02-28 23:25:34 +0000608 // TODO: b/263304156 update this to make use of a death callback for more
609 // robust/fault tolerant logging
610 static const sp<IActivityManager>& getActivityManager() {
611 static const char* kActivityService = "activity";
612 static const auto activityManager = []() -> sp<IActivityManager> {
613 const sp<IServiceManager> sm(defaultServiceManager());
614 if (sm != nullptr) {
615 return interface_cast<IActivityManager>(sm->checkService(String16(kActivityService)));
616 }
617 return nullptr;
618 }();
619 return activityManager;
620 }
621
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800622 /**
623 * Typesafe version of device status, containing both the HAL-layer and the service interface-
624 * layer values.
625 */
626 enum class StatusInternal : int32_t {
627 NOT_PRESENT = static_cast<int32_t>(CameraDeviceStatus::NOT_PRESENT),
628 PRESENT = static_cast<int32_t>(CameraDeviceStatus::PRESENT),
629 ENUMERATING = static_cast<int32_t>(CameraDeviceStatus::ENUMERATING),
630 NOT_AVAILABLE = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE),
631 UNKNOWN = static_cast<int32_t>(hardware::ICameraServiceListener::STATUS_UNKNOWN)
632 };
633
Ruben Brunkcc776712015-02-17 20:18:47 -0800634 /**
635 * Container class for the state of each logical camera device, including: ID, status, and
636 * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates
637 * represents the camera devices advertised by the HAL (and any USB devices, when we add
638 * those).
639 *
640 * This container does NOT represent an active camera client. These are represented using
641 * the ClientDescriptors stored in mActiveClientManager.
642 */
643 class CameraState {
644 public:
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800645
Ruben Brunkcc776712015-02-17 20:18:47 -0800646 /**
647 * Make a new CameraState and set the ID, cost, and conflicting devices using the values
648 * returned in the HAL's camera_info struct for each device.
649 */
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700650 CameraState(const String8& id, int cost, const std::set<String8>& conflicting,
Shuzhen Wang403af6d2021-12-21 00:08:43 +0000651 SystemCameraKind deviceKind, const std::vector<std::string>& physicalCameras);
Ruben Brunkcc776712015-02-17 20:18:47 -0800652 virtual ~CameraState();
653
654 /**
655 * Return the status for this device.
656 *
657 * This method acquires mStatusLock.
658 */
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800659 StatusInternal getStatus() const;
Ruben Brunkcc776712015-02-17 20:18:47 -0800660
661 /**
662 * This function updates the status for this camera device, unless the given status
663 * is in the given list of rejected status states, and execute the function passed in
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800664 * with a signature onStatusUpdateLocked(const String8&, int32_t)
Ruben Brunkcc776712015-02-17 20:18:47 -0800665 * if the status has changed.
666 *
667 * This method is idempotent, and will not result in the function passed to
668 * onStatusUpdateLocked being called more than once for the same arguments.
669 * This method aquires mStatusLock.
670 */
671 template<class Func>
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800672 void updateStatus(StatusInternal status,
673 const String8& cameraId,
674 std::initializer_list<StatusInternal> rejectSourceStates,
Ruben Brunkcc776712015-02-17 20:18:47 -0800675 Func onStatusUpdatedLocked);
676
677 /**
678 * Return the last set CameraParameters object generated from the information returned by
679 * the HAL for this device (or an empty CameraParameters object if none has been set).
680 */
681 CameraParameters getShimParams() const;
682
683 /**
684 * Set the CameraParameters for this device.
685 */
686 void setShimParams(const CameraParameters& params);
687
688 /**
689 * Return the resource_cost advertised by the HAL for this device.
690 */
691 int getCost() const;
692
693 /**
694 * Return a set of the IDs of conflicting devices advertised by the HAL for this device.
695 */
696 std::set<String8> getConflicting() const;
697
698 /**
699 * Return the ID of this camera device.
700 */
701 String8 getId() const;
702
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700703 /**
704 * Return the kind (SystemCameraKind) of this camera device.
705 */
706 SystemCameraKind getSystemCameraKind() const;
707
Shuzhen Wang43858162020-01-10 13:42:15 -0800708 /**
Shuzhen Wang403af6d2021-12-21 00:08:43 +0000709 * Return whether this camera is a logical multi-camera and has a
710 * particular physical sub-camera.
711 */
712 bool containsPhysicalCamera(const std::string& physicalCameraId) const;
713
714 /**
Shuzhen Wang43858162020-01-10 13:42:15 -0800715 * Add/Remove the unavailable physical camera ID.
716 */
717 bool addUnavailablePhysicalId(const String8& physicalId);
718 bool removeUnavailablePhysicalId(const String8& physicalId);
719
720 /**
Shuzhen Wange7aa0342021-08-03 11:29:47 -0700721 * Set and get client package name.
722 */
723 void setClientPackage(const String8& clientPackage);
724 String8 getClientPackage() const;
725
726 /**
Shuzhen Wang43858162020-01-10 13:42:15 -0800727 * Return the unavailable physical ids for this device.
728 *
729 * This method acquires mStatusLock.
730 */
731 std::vector<String8> getUnavailablePhysicalIds() const;
Ruben Brunkcc776712015-02-17 20:18:47 -0800732 private:
733 const String8 mId;
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -0800734 StatusInternal mStatus; // protected by mStatusLock
Ruben Brunkcc776712015-02-17 20:18:47 -0800735 const int mCost;
736 std::set<String8> mConflicting;
Shuzhen Wang43858162020-01-10 13:42:15 -0800737 std::set<String8> mUnavailablePhysicalIds;
Shuzhen Wange7aa0342021-08-03 11:29:47 -0700738 String8 mClientPackage;
Ruben Brunkcc776712015-02-17 20:18:47 -0800739 mutable Mutex mStatusLock;
740 CameraParameters mShimParams;
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700741 const SystemCameraKind mSystemCameraKind;
Shuzhen Wang403af6d2021-12-21 00:08:43 +0000742 const std::vector<std::string> mPhysicalCameras; // Empty if not a logical multi-camera
Ruben Brunkcc776712015-02-17 20:18:47 -0800743 }; // class CameraState
744
Svet Ganova453d0d2018-01-11 15:37:58 -0800745 // Observer for UID lifecycle enforcing that UIDs in idle
746 // state cannot use the camera to protect user privacy.
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800747 class UidPolicy :
748 public BnUidObserver,
749 public virtual IBinder::DeathRecipient,
750 public virtual IServiceManager::LocalRegistrationCallback {
Svet Ganova453d0d2018-01-11 15:37:58 -0800751 public:
752 explicit UidPolicy(sp<CameraService> service)
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -0700753 : mRegistered(false), mService(service) {}
Svet Ganova453d0d2018-01-11 15:37:58 -0800754
755 void registerSelf();
756 void unregisterSelf();
757
Svet Ganov7b4ab782018-03-25 12:48:10 -0700758 bool isUidActive(uid_t uid, String16 callingPackage);
Varun Shahb42f1eb2019-04-16 14:45:13 -0700759 int32_t getProcState(uid_t uid);
Svet Ganova453d0d2018-01-11 15:37:58 -0800760
Austin Borger65577682022-02-17 00:25:43 +0000761 // IUidObserver
762 void onUidGone(uid_t uid, bool disabled) override;
763 void onUidActive(uid_t uid) override;
764 void onUidIdle(uid_t uid, bool disabled) override;
Hui Yu13ad0eb2019-09-09 10:27:07 -0700765 void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq,
Austin Borger65577682022-02-17 00:25:43 +0000766 int32_t capability) override;
Austin Borgerdddb7552023-03-30 17:53:01 -0700767 void onUidProcAdjChanged(uid_t uid, int adj) override;
Svet Ganova453d0d2018-01-11 15:37:58 -0800768
Svet Ganov7b4ab782018-03-25 12:48:10 -0700769 void addOverrideUid(uid_t uid, String16 callingPackage, bool active);
770 void removeOverrideUid(uid_t uid, String16 callingPackage);
Svet Ganova453d0d2018-01-11 15:37:58 -0800771
Austin Borgerdddb7552023-03-30 17:53:01 -0700772 void registerMonitorUid(uid_t uid, bool openCamera);
773 void unregisterMonitorUid(uid_t uid, bool closeCamera);
Emilian Peev53722fa2019-02-22 17:47:20 -0800774
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800775 // Implementation of IServiceManager::LocalRegistrationCallback
776 virtual void onServiceRegistration(const String16& name,
777 const sp<IBinder>& binder) override;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -0700778 // IBinder::DeathRecipient implementation
779 virtual void binderDied(const wp<IBinder> &who);
Svet Ganova453d0d2018-01-11 15:37:58 -0800780 private:
Svet Ganov7b4ab782018-03-25 12:48:10 -0700781 bool isUidActiveLocked(uid_t uid, String16 callingPackage);
Varun Shahb42f1eb2019-04-16 14:45:13 -0700782 int32_t getProcStateLocked(uid_t uid);
Svet Ganov7b4ab782018-03-25 12:48:10 -0700783 void updateOverrideUid(uid_t uid, String16 callingPackage, bool active, bool insert);
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800784 void registerWithActivityManager();
Svet Ganova453d0d2018-01-11 15:37:58 -0800785
Austin Borger65577682022-02-17 00:25:43 +0000786 struct MonitoredUid {
787 int32_t procState;
Austin Borgerdddb7552023-03-30 17:53:01 -0700788 int32_t procAdj;
789 bool hasCamera;
Austin Borger65577682022-02-17 00:25:43 +0000790 size_t refCount;
791 };
792
Svet Ganova453d0d2018-01-11 15:37:58 -0800793 Mutex mUidLock;
Eino-Ville Talvala8abec3f2018-03-20 11:07:00 -0700794 bool mRegistered;
Steven Moreland2f348142019-07-02 15:59:07 -0700795 ActivityManager mAm;
Svet Ganova453d0d2018-01-11 15:37:58 -0800796 wp<CameraService> mService;
797 std::unordered_set<uid_t> mActiveUids;
Austin Borger65577682022-02-17 00:25:43 +0000798 // Monitored uid map
799 std::unordered_map<uid_t, MonitoredUid> mMonitoredUids;
Svet Ganova453d0d2018-01-11 15:37:58 -0800800 std::unordered_map<uid_t, bool> mOverrideUids;
Austin Borgerd0309d42023-04-21 20:07:18 -0700801 sp<IBinder> mObserverToken;
Svet Ganova453d0d2018-01-11 15:37:58 -0800802 }; // class UidPolicy
803
Michael Grooverd1d435a2018-12-18 17:39:42 -0800804 // If sensor privacy is enabled then all apps, including those that are active, should be
805 // prevented from accessing the camera.
806 class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener,
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800807 public virtual IBinder::DeathRecipient,
808 public virtual IServiceManager::LocalRegistrationCallback {
Michael Grooverd1d435a2018-12-18 17:39:42 -0800809 public:
810 explicit SensorPrivacyPolicy(wp<CameraService> service)
Evan Severson671806e2021-04-20 16:44:53 -0700811 : mService(service), mSensorPrivacyEnabled(false), mRegistered(false) {}
Michael Grooverd1d435a2018-12-18 17:39:42 -0800812
813 void registerSelf();
814 void unregisterSelf();
815
816 bool isSensorPrivacyEnabled();
Evan Seversond0b69922022-01-27 10:47:34 -0800817 bool isCameraPrivacyEnabled();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800818
Evan Seversond0b69922022-01-27 10:47:34 -0800819 binder::Status onSensorPrivacyChanged(int toggleType, int sensor,
820 bool enabled);
Michael Grooverd1d435a2018-12-18 17:39:42 -0800821
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800822 // Implementation of IServiceManager::LocalRegistrationCallback
823 virtual void onServiceRegistration(const String16& name,
824 const sp<IBinder>& binder) override;
Michael Grooverd1d435a2018-12-18 17:39:42 -0800825 // IBinder::DeathRecipient implementation
826 virtual void binderDied(const wp<IBinder> &who);
827
828 private:
Steven Moreland3cf67172020-01-29 11:44:22 -0800829 SensorPrivacyManager mSpm;
Michael Grooverd1d435a2018-12-18 17:39:42 -0800830 wp<CameraService> mService;
831 Mutex mSensorPrivacyLock;
832 bool mSensorPrivacyEnabled;
833 bool mRegistered;
Evan Severson09ab4002021-02-10 14:15:19 -0800834
835 bool hasCameraPrivacyFeature();
Jyoti Bhayanacde601c2022-12-07 10:03:42 -0800836 void registerWithSensorPrivacyManager();
Michael Grooverd1d435a2018-12-18 17:39:42 -0800837 };
838
Svet Ganova453d0d2018-01-11 15:37:58 -0800839 sp<UidPolicy> mUidPolicy;
840
Michael Grooverd1d435a2018-12-18 17:39:42 -0800841 sp<SensorPrivacyPolicy> mSensorPrivacyPolicy;
842
Austin Borger74fca042022-05-23 12:41:21 -0700843 std::shared_ptr<CameraServiceProxyWrapper> mCameraServiceProxyWrapper;
844
Igor Murashkin634a5152013-02-20 17:15:11 -0800845 // Delay-load the Camera HAL module
846 virtual void onFirstRef();
847
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800848 // Eumerate all camera providers in the system
849 status_t enumerateProviders();
850
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800851 // Add/remove a new camera to camera and torch state lists or remove an unplugged one
852 // Caller must not hold mServiceLock
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100853 void addStates(const String8 id);
Guennadi Liakhovetski6034bf52017-12-07 10:28:29 +0100854 void removeStates(const String8 id);
Guennadi Liakhovetski151e3be2017-11-28 16:34:18 +0100855
Ruben Brunkcc776712015-02-17 20:18:47 -0800856 // Check if we can connect, before we acquire the service lock.
Chien-Yu Chen18df60e2016-03-18 18:18:09 -0700857 // The returned originalClientPid is the PID of the original process that wants to connect to
858 // camera.
859 // The returned clientPid is the PID of the client that directly connects to camera.
860 // originalClientPid and clientPid are usually the same except when the application uses
861 // mediaserver to connect to camera (using MediaRecorder to connect to camera). In that case,
862 // clientPid is the PID of mediaserver and originalClientPid is the PID of the application.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800863 binder::Status validateConnectLocked(const String8& cameraId, const String8& clientName8,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700864 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const;
Eino-Ville Talvala04926862016-03-02 15:42:53 -0800865 binder::Status validateClientPermissionsLocked(const String8& cameraId, const String8& clientName8,
Chien-Yu Chen7939aee2016-03-21 18:19:33 -0700866 /*inout*/int& clientUid, /*inout*/int& clientPid, /*out*/int& originalClientPid) const;
Igor Murashkine6800ce2013-03-04 17:25:57 -0800867
Ruben Brunkcc776712015-02-17 20:18:47 -0800868 // Handle active client evictions, and update service state.
869 // Only call with with mServiceLock held.
870 status_t handleEvictionsLocked(const String8& cameraId, int clientPid,
871 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800872 int scoreOffset, bool systemNativeClient,
Ruben Brunkcc776712015-02-17 20:18:47 -0800873 /*out*/
874 sp<BasicClient>* client,
875 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800876
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700877 // Should an operation attempt on a cameraId be rejected ? (this can happen
878 // under various conditions. For example if a camera device is advertised as
879 // system only or hidden secure camera, amongst possible others.
880 bool shouldRejectSystemCameraConnection(const String8 & cameraId) const;
881
882 // Should a device status update be skipped for a particular camera device ? (this can happen
883 // under various conditions. For example if a camera device is advertised as
884 // system only or hidden secure camera, amongst possible others.
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700885 static bool shouldSkipStatusUpdates(SystemCameraKind systemCameraKind, bool isVendorListener,
886 int clientPid, int clientUid);
Jayant Chowdhary5216b212019-07-17 09:26:23 -0700887
Jayant Chowdhary33e8ef82019-09-27 09:20:42 -0700888 // Gets the kind of camera device (i.e public, hidden secure or system only)
889 // getSystemCameraKind() needs mInterfaceMutex which might lead to deadlocks
890 // if held along with mStatusListenerLock (depending on lock ordering, b/141756275), it is
891 // recommended that we don't call this function with mStatusListenerLock held.
892 status_t getSystemCameraKind(const String8& cameraId, SystemCameraKind *kind) const;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -0800893
Jayant Chowdhary847947d2019-08-30 18:02:59 -0700894 // Update the set of API1Compatible camera devices without including system
895 // cameras and secure cameras. This is used for hiding system only cameras
896 // from clients using camera1 api and not having android.permission.SYSTEM_CAMERA.
897 // This function expects @param normalDeviceIds, to have normalDeviceIds
898 // sorted in alpha-numeric order.
899 void filterAPI1SystemCameraLocked(const std::vector<std::string> &normalDeviceIds);
900
Eino-Ville Talvala58106af2022-09-23 16:51:06 -0700901 // In some cases the calling code has no access to the package it runs under.
902 // For example, NDK camera API.
903 // In this case we will get the packages for the calling UID and pick the first one
904 // for attributing the app op. This will work correctly for runtime permissions
905 // as for legacy apps we will toggle the app op for all packages in the UID.
906 // The caveat is that the operation may be attributed to the wrong package and
907 // stats based on app ops may be slightly off.
908 String16 getPackageNameFromUid(int clientUid);
909
Ruben Brunkcc776712015-02-17 20:18:47 -0800910 // Single implementation shared between the various connect calls
911 template<class CALLBACK, class CLIENT>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800912 binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
Eino-Ville Talvala58106af2022-09-23 16:51:06 -0700913 int api1CameraId, const String16& clientPackageNameMaybe, bool systemNativeClient,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +0900914 const std::optional<String16>& clientFeatureId, int clientUid, int clientPid,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700915 apiLevel effectiveApiLevel, bool shimUpdateOnly, int scoreOffset, int targetSdkVersion,
Chengfei Taobe683db2023-01-31 18:52:49 +0000916 bool overrideToPortrait, bool forceSlowJpegMode,
917 /*out*/sp<CLIENT>& device);
Igor Murashkine6800ce2013-03-04 17:25:57 -0800918
Ruben Brunkcc776712015-02-17 20:18:47 -0800919 // Lock guarding camera service state
Mathias Agopian65ab4712010-07-14 17:59:35 -0700920 Mutex mServiceLock;
Ruben Brunkcc776712015-02-17 20:18:47 -0800921
922 // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients
923 std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper;
924
925 // Return NO_ERROR if the device with a give ID can be connected to
926 status_t checkIfDeviceIsUsable(const String8& cameraId) const;
927
928 // Container for managing currently active application-layer clients
929 CameraClientManager mActiveClientManager;
930
Rucha Katakwardf223072021-06-15 10:21:00 -0700931 // Adds client logs during open session to the file pointed by fd.
932 void dumpOpenSessionClientLogs(int fd, const Vector<String16>& args, const String8& cameraId);
933
934 // Adds client logs during closed session to the file pointed by fd.
935 void dumpClosedSessionClientLogs(int fd, const String8& cameraId);
936
Ruben Brunkcc776712015-02-17 20:18:47 -0800937 // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock
938 std::map<String8, std::shared_ptr<CameraState>> mCameraStates;
939
940 // Mutex guarding mCameraStates map
941 mutable Mutex mCameraStatesLock;
942
943 // Circular buffer for storing event logging for dumps
944 RingBuffer<String8> mEventLog;
Ruben Brunka8ca9152015-04-07 14:23:40 -0700945 Mutex mLogLock;
Ruben Brunkcc776712015-02-17 20:18:47 -0800946
Avichal Rakesh7fbc3982021-10-20 04:35:03 -0700947 // set of client package names to watch. if this set contains 'all', then all clients will
948 // be watched. Access should be guarded by mLogLock
949 std::set<String16> mWatchedClientPackages;
950 // cache of last monitored tags dump immediately before the client disconnects. If a client
951 // re-connects, its entry is not updated until it disconnects again. Access should be guarded
952 // by mLogLock
953 std::map<String16, std::string> mWatchedClientsDumpCache;
954
Emilian Peevbd8c5032018-02-14 23:05:40 +0000955 // The last monitored tags set by client
956 String8 mMonitorTags;
957
Ruben Brunk6267b532015-04-30 17:44:07 -0700958 // Currently allowed user IDs
959 std::set<userid_t> mAllowedUsers;
Ruben Brunk36597b22015-03-20 22:15:57 -0700960
Ruben Brunkcc776712015-02-17 20:18:47 -0800961 /**
962 * Get the camera state for a given camera id.
963 *
964 * This acquires mCameraStatesLock.
965 */
966 std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const;
967
968 /**
969 * Evict client who's remote binder has died. Returns true if this client was in the active
970 * list and was disconnected.
971 *
972 * This method acquires mServiceLock.
973 */
974 bool evictClientIdByRemote(const wp<IBinder>& cameraClient);
975
976 /**
977 * Remove the given client from the active clients list; does not disconnect the client.
978 *
979 * This method acquires mServiceLock.
980 */
981 void removeByClient(const BasicClient* client);
982
983 /**
984 * Add new client to active clients list after conflicting clients have disconnected using the
985 * values set in the partial descriptor passed in to construct the actual client descriptor.
986 * This is typically called at the end of a connect call.
987 *
988 * This method must be called with mServiceLock held.
989 */
Jayant Chowdhary8eb8d912021-05-18 17:41:56 +0000990 void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -0800991 int oomScoreOffset, bool systemNativeClient);
Ruben Brunkcc776712015-02-17 20:18:47 -0800992
993 /**
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800994 * Returns the underlying camera Id string mapped to a camera id int
995 * Empty string is returned when the cameraIdInt is invalid.
Ruben Brunkcc776712015-02-17 20:18:47 -0800996 */
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -0800997 String8 cameraIdIntToStr(int cameraIdInt);
998
999 /**
1000 * Returns the underlying camera Id string mapped to a camera id int
1001 * Empty string is returned when the cameraIdInt is invalid.
1002 */
1003 std::string cameraIdIntToStrLocked(int cameraIdInt);
Ruben Brunkcc776712015-02-17 20:18:47 -08001004
1005 /**
1006 * Remove a single client corresponding to the given camera id from the list of active clients.
1007 * If none exists, return an empty strongpointer.
1008 *
1009 * This method must be called with mServiceLock held.
1010 */
1011 sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId);
1012
1013 /**
Ruben Brunk36597b22015-03-20 22:15:57 -07001014 * Handle a notification that the current device user has changed.
1015 */
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001016 void doUserSwitch(const std::vector<int32_t>& newUserIds);
Ruben Brunk36597b22015-03-20 22:15:57 -07001017
1018 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001019 * Add an event log message.
Ruben Brunkcc776712015-02-17 20:18:47 -08001020 */
Ruben Brunka8ca9152015-04-07 14:23:40 -07001021 void logEvent(const char* event);
Ruben Brunkcc776712015-02-17 20:18:47 -08001022
1023 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001024 * Add an event log message that a client has been disconnected.
Ruben Brunkcc776712015-02-17 20:18:47 -08001025 */
Ruben Brunka8ca9152015-04-07 14:23:40 -07001026 void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage);
1027
1028 /**
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001029 * Add an event log message that a client has been disconnected from offline device.
1030 */
1031 void logDisconnectedOffline(const char* cameraId, int clientPid, const char* clientPackage);
1032
1033 /**
1034 * Add an event log message that an offline client has been connected.
1035 */
1036 void logConnectedOffline(const char* cameraId, int clientPid,
1037 const char* clientPackage);
1038
1039 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001040 * Add an event log message that a client has been connected.
1041 */
1042 void logConnected(const char* cameraId, int clientPid, const char* clientPackage);
1043
1044 /**
1045 * Add an event log message that a client's connect attempt has been rejected.
1046 */
1047 void logRejected(const char* cameraId, int clientPid, const char* clientPackage,
1048 const char* reason);
1049
1050 /**
Jayant Chowdhary0e2eefd2019-04-18 14:05:43 -07001051 * Add an event log message when a client calls setTorchMode succesfully.
1052 */
1053 void logTorchEvent(const char* cameraId, const char *torchState, int clientPid);
1054
1055 /**
Ruben Brunka8ca9152015-04-07 14:23:40 -07001056 * Add an event log message that the current device user has been switched.
1057 */
Ruben Brunk6267b532015-04-30 17:44:07 -07001058 void logUserSwitch(const std::set<userid_t>& oldUserIds,
1059 const std::set<userid_t>& newUserIds);
Ruben Brunka8ca9152015-04-07 14:23:40 -07001060
1061 /**
1062 * Add an event log message that a device has been removed by the HAL
1063 */
1064 void logDeviceRemoved(const char* cameraId, const char* reason);
1065
1066 /**
1067 * Add an event log message that a device has been added by the HAL
1068 */
1069 void logDeviceAdded(const char* cameraId, const char* reason);
1070
1071 /**
1072 * Add an event log message that a client has unexpectedly died.
1073 */
1074 void logClientDied(int clientPid, const char* reason);
Ruben Brunkcc776712015-02-17 20:18:47 -08001075
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07001076 /**
1077 * Add a event log message that a serious service-level error has occured
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001078 * The errorCode should be one of the Android Errors
Eino-Ville Talvala1527f072015-04-07 15:55:31 -07001079 */
1080 void logServiceError(const char* msg, int errorCode);
1081
1082 /**
1083 * Dump the event log to an FD
1084 */
1085 void dumpEventLog(int fd);
1086
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001087 void cacheClientTagDumpIfNeeded(const char *cameraId, BasicClient *client);
1088
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001089 /**
1090 * This method will acquire mServiceLock
1091 */
1092 void updateCameraNumAndIds();
1093
Shuzhen Wang89db2992021-05-20 13:09:48 -07001094 /**
Shuzhen Wangb38b53f2021-07-15 12:46:09 -07001095 * Filter camera characteristics for S Performance class primary cameras.
1096 * mServiceLock should be locked.
Shuzhen Wang89db2992021-05-20 13:09:48 -07001097 */
Shuzhen Wangb38b53f2021-07-15 12:46:09 -07001098 void filterSPerfClassCharacteristicsLocked();
Shuzhen Wang89db2992021-05-20 13:09:48 -07001099
Rucha Katakwardf223072021-06-15 10:21:00 -07001100 // File descriptor to temp file used for caching previous open
1101 // session dumpsys info.
1102 int mMemFd;
1103
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001104 // Number of camera devices (excluding hidden secure cameras)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001105 int mNumberOfCameras;
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001106 // Number of camera devices (excluding hidden secure cameras and
1107 // system cameras)
1108 int mNumberOfCamerasWithoutSystemCamera;
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -08001109
1110 std::vector<std::string> mNormalDeviceIds;
Jayant Chowdhary847947d2019-08-30 18:02:59 -07001111 std::vector<std::string> mNormalDeviceIdsWithoutSystemCamera;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001112 std::set<std::string> mPerfClassPrimaryCameraIds;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001113
Mathias Agopian65ab4712010-07-14 17:59:35 -07001114 // sounds
Jaekyun Seokef498052018-03-23 13:09:44 +09001115 sp<MediaPlayer> newMediaPlayer(const char *file);
Chih-Chung Changff4f55c2011-10-17 19:03:12 +08001116
Mathias Agopian65ab4712010-07-14 17:59:35 -07001117 Mutex mSoundLock;
1118 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS];
1119 int mSoundRef; // reference count (release all MediaPlayer when 0)
1120
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001121 // Basic flag on whether the camera subsystem is in a usable state
1122 bool mInitialized;
1123
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001124 sp<CameraProviderManager> mCameraProviderManager;
Igor Murashkinecf17e82012-10-02 16:05:11 -07001125
Emilian Peev53722fa2019-02-22 17:47:20 -08001126 class ServiceListener : public virtual IBinder::DeathRecipient {
1127 public:
1128 ServiceListener(sp<CameraService> parent, sp<hardware::ICameraServiceListener> listener,
Shuzhen Wang695044d2020-03-06 09:02:23 -08001129 int uid, int pid, bool isVendorClient, bool openCloseCallbackAllowed)
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001130 : mParent(parent), mListener(listener), mListenerUid(uid), mListenerPid(pid),
Shuzhen Wang695044d2020-03-06 09:02:23 -08001131 mIsVendorListener(isVendorClient),
1132 mOpenCloseCallbackAllowed(openCloseCallbackAllowed) { }
Emilian Peev53722fa2019-02-22 17:47:20 -08001133
Jayant Chowdhary32ced0e2021-04-09 14:00:22 -07001134 status_t initialize(bool isProcessLocalTest) {
1135 if (isProcessLocalTest) {
1136 return OK;
1137 }
Emilian Peev53722fa2019-02-22 17:47:20 -08001138 return IInterface::asBinder(mListener)->linkToDeath(this);
1139 }
1140
Austin Borgere8e2c422022-05-12 13:45:24 -07001141 template<typename... args_t>
1142 void handleBinderStatus(const binder::Status &ret, const char *logOnError,
1143 args_t... args) {
1144 if (!ret.isOk() &&
1145 (ret.exceptionCode() != binder::Status::Exception::EX_TRANSACTION_FAILED
1146 || !mLastTransactFailed)) {
1147 ALOGE(logOnError, args...);
1148 }
1149
1150 // If the transaction failed, the process may have died (or other things, see
1151 // b/28321379). Mute consecutive errors from this listener to avoid log spam.
1152 if (ret.exceptionCode() == binder::Status::Exception::EX_TRANSACTION_FAILED) {
1153 if (!mLastTransactFailed) {
1154 ALOGE("%s: Muting similar errors from listener %d:%d", __FUNCTION__,
1155 mListenerUid, mListenerPid);
1156 }
1157 mLastTransactFailed = true;
1158 } else {
1159 // Reset mLastTransactFailed when binder becomes healthy again.
1160 mLastTransactFailed = false;
1161 }
1162 }
1163
Emilian Peev53722fa2019-02-22 17:47:20 -08001164 virtual void binderDied(const wp<IBinder> &/*who*/) {
1165 auto parent = mParent.promote();
1166 if (parent.get() != nullptr) {
1167 parent->removeListener(mListener);
1168 }
1169 }
1170
1171 int getListenerUid() { return mListenerUid; }
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001172 int getListenerPid() { return mListenerPid; }
Emilian Peev53722fa2019-02-22 17:47:20 -08001173 sp<hardware::ICameraServiceListener> getListener() { return mListener; }
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001174 bool isVendorListener() { return mIsVendorListener; }
Shuzhen Wang695044d2020-03-06 09:02:23 -08001175 bool isOpenCloseCallbackAllowed() { return mOpenCloseCallbackAllowed; }
Emilian Peev53722fa2019-02-22 17:47:20 -08001176
1177 private:
1178 wp<CameraService> mParent;
1179 sp<hardware::ICameraServiceListener> mListener;
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001180 int mListenerUid = -1;
1181 int mListenerPid = -1;
1182 bool mIsVendorListener = false;
Shuzhen Wang695044d2020-03-06 09:02:23 -08001183 bool mOpenCloseCallbackAllowed = false;
Austin Borgere8e2c422022-05-12 13:45:24 -07001184
1185 // Flag for preventing log spam when binder becomes unhealthy
1186 bool mLastTransactFailed = false;
Emilian Peev53722fa2019-02-22 17:47:20 -08001187 };
1188
Ruben Brunkcc776712015-02-17 20:18:47 -08001189 // Guarded by mStatusListenerMutex
Jayant Chowdhary5216b212019-07-17 09:26:23 -07001190 std::vector<sp<ServiceListener>> mListenerList;
Jayant Chowdharyf949ddd2019-01-29 14:34:11 -08001191
Ruben Brunkcc776712015-02-17 20:18:47 -08001192 Mutex mStatusListenerLock;
Igor Murashkinbfc99152013-02-27 12:55:20 -08001193
Ruben Brunkcc776712015-02-17 20:18:47 -08001194 /**
1195 * Update the status for the given camera id (if that device exists), and broadcast the
1196 * status update to all current ICameraServiceListeners if the status has changed. Any
1197 * statuses in rejectedSourceStates will be ignored.
1198 *
1199 * This method must be idempotent.
1200 * This method acquires mStatusLock and mStatusListenerLock.
1201 */
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001202 void updateStatus(StatusInternal status,
1203 const String8& cameraId,
1204 std::initializer_list<StatusInternal>
1205 rejectedSourceStates);
1206 void updateStatus(StatusInternal status,
1207 const String8& cameraId);
Igor Murashkinbfc99152013-02-27 12:55:20 -08001208
Shuzhen Wang695044d2020-03-06 09:02:23 -08001209 /**
1210 * Update the opened/closed status of the given camera id.
1211 *
1212 * This method acqiures mStatusListenerLock.
1213 */
1214 void updateOpenCloseStatus(const String8& cameraId, bool open, const String16& packageName);
1215
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001216 // flashlight control
1217 sp<CameraFlashlight> mFlashlight;
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001218 // guard mTorchStatusMap
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001219 Mutex mTorchStatusMutex;
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001220 // guard mTorchClientMap
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001221 Mutex mTorchClientMapMutex;
Chien-Yu Chenfe751be2015-09-01 14:16:44 -07001222 // guard mTorchUidMap
1223 Mutex mTorchUidMapMutex;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001224 // camera id -> torch status
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001225 KeyedVector<String8, TorchModeStatus>
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001226 mTorchStatusMap;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001227 // camera id -> torch client binder
1228 // only store the last client that turns on each camera's torch mode
Ruben Brunk99e69712015-05-26 17:25:07 -07001229 KeyedVector<String8, sp<IBinder>> mTorchClientMap;
1230 // camera id -> [incoming uid, current uid] pair
1231 std::map<String8, std::pair<int, int>> mTorchUidMap;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001232
1233 // check and handle if torch client's process has died
1234 void handleTorchClientBinderDied(const wp<IBinder> &who);
1235
1236 // handle torch mode status change and invoke callbacks. mTorchStatusMutex
1237 // should be locked.
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001238 void onTorchStatusChangedLocked(const String8& cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001239 TorchModeStatus newStatus,
Jayant Chowdhary8c62d892021-03-31 02:13:46 -07001240 SystemCameraKind systemCameraKind);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001241
1242 // get a camera's torch status. mTorchStatusMutex should be locked.
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001243 status_t getTorchStatusLocked(const String8 &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001244 TorchModeStatus *status) const;
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001245
1246 // set a camera's torch status. mTorchStatusMutex should be locked.
Chien-Yu Chen88da5262015-02-17 13:56:46 -08001247 status_t setTorchStatusLocked(const String8 &cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001248 TorchModeStatus status);
Chien-Yu Chen3068d732015-02-09 13:29:57 -08001249
Shuzhen Wang43858162020-01-10 13:42:15 -08001250 // notify physical camera status when the physical camera is public.
Jayant Chowdhary5e2cd302020-08-14 02:48:34 +00001251 // Expects mStatusListenerLock to be locked.
1252 void notifyPhysicalCameraStatusLocked(int32_t status, const String16& physicalCameraId,
1253 const std::list<String16>& logicalCameraIds, SystemCameraKind deviceKind);
1254
1255 // get list of logical cameras which are backed by physicalCameraId
1256 std::list<String16> getLogicalCameras(const String8& physicalCameraId);
1257
Shuzhen Wang43858162020-01-10 13:42:15 -08001258
Igor Murashkinecf17e82012-10-02 16:05:11 -07001259 // IBinder::DeathRecipient implementation
Igor Murashkinbfc99152013-02-27 12:55:20 -08001260 virtual void binderDied(const wp<IBinder> &who);
Igor Murashkin634a5152013-02-20 17:15:11 -08001261
Ruben Brunkb2119af2014-05-09 19:57:56 -07001262 /**
Ruben Brunkb2119af2014-05-09 19:57:56 -07001263 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId.
1264 *
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001265 * Sets Status to a service-specific error on failure
Ruben Brunkb2119af2014-05-09 19:57:56 -07001266 */
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001267 binder::Status initializeShimMetadata(int cameraId);
Ruben Brunkb2119af2014-05-09 19:57:56 -07001268
1269 /**
Igor Murashkin65d14b92014-06-17 12:03:20 -07001270 * Get the cached CameraParameters for the camera. If they haven't been
1271 * cached yet, then initialize them for the first time.
1272 *
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001273 * Sets Status to a service-specific error on failure
Igor Murashkin65d14b92014-06-17 12:03:20 -07001274 */
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001275 binder::Status getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters);
Igor Murashkin65d14b92014-06-17 12:03:20 -07001276
Svet Ganova453d0d2018-01-11 15:37:58 -08001277 // Blocks all clients from the UID
1278 void blockClientsForUid(uid_t uid);
1279
Michael Grooverd1d435a2018-12-18 17:39:42 -08001280 // Blocks all active clients.
1281 void blockAllClients();
1282
Svet Ganova453d0d2018-01-11 15:37:58 -08001283 // Overrides the UID state as if it is idle
1284 status_t handleSetUidState(const Vector<String16>& args, int err);
1285
1286 // Clears the override for the UID state
1287 status_t handleResetUidState(const Vector<String16>& args, int err);
1288
1289 // Gets the UID state
1290 status_t handleGetUidState(const Vector<String16>& args, int out, int err);
1291
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001292 // Set the rotate-and-crop AUTO override behavior
1293 status_t handleSetRotateAndCrop(const Vector<String16>& args);
1294
1295 // Get the rotate-and-crop AUTO override behavior
1296 status_t handleGetRotateAndCrop(int out);
1297
Bharatt Kukreja7146ced2022-10-25 15:45:29 +00001298 // Set the autoframing AUTO override behaviour.
1299 status_t handleSetAutoframing(const Vector<String16>& args);
1300
1301 // Get the autoframing AUTO override behaviour
1302 status_t handleGetAutoframing(int out);
1303
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001304 // Set the mask for image dump to disk
1305 status_t handleSetImageDumpMask(const Vector<String16>& args);
1306
1307 // Get the mask for image dump to disk
1308 status_t handleGetImageDumpMask(int out);
1309
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001310 // Set the camera mute state
1311 status_t handleSetCameraMute(const Vector<String16>& args);
1312
Shuzhen Wang16610a62022-12-15 22:38:07 -08001313 // Set the stream use case overrides
1314 status_t handleSetStreamUseCaseOverrides(const Vector<String16>& args);
1315
1316 // Clear the stream use case overrides
1317 void handleClearStreamUseCaseOverrides();
1318
Shuzhen Wangaf22e912023-04-11 16:03:17 -07001319 // Set or clear the zoom override flag
1320 status_t handleSetZoomOverride(const Vector<String16>& args);
1321
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001322 // Handle 'watch' command as passed through 'cmd'
Avichal Rakesh84147132021-11-11 17:47:11 -08001323 status_t handleWatchCommand(const Vector<String16> &args, int inFd, int outFd);
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001324
Ravneetaeb20dc2022-03-30 05:33:03 +00001325 // Set the camera service watchdog
1326 status_t handleSetCameraServiceWatchdog(const Vector<String16>& args);
1327
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001328 // Enable tag monitoring of the given tags in provided clients
1329 status_t startWatchingTags(const Vector<String16> &args, int outFd);
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001330
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001331 // Disable tag monitoring
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001332 status_t stopWatchingTags(int outFd);
1333
Avichal Rakesh3a85d2d2021-11-10 16:21:33 -08001334 // Clears mWatchedClientsDumpCache
1335 status_t clearCachedMonitoredTagDumps(int outFd);
1336
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001337 // Print events of monitored tags in all cached and attached clients
Avichal Rakesh9e5a1e42021-11-15 12:11:21 -08001338 status_t printWatchedTags(int outFd);
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001339
1340 // Print events of monitored tags in all attached clients as they are captured. New events are
Avichal Rakesh84147132021-11-11 17:47:11 -08001341 // fetched every `refreshMillis` ms
1342 // NOTE: This function does not terminate until user passes '\n' to inFd.
Avichal Rakesh9e5a1e42021-11-15 12:11:21 -08001343 status_t printWatchedTagsUntilInterrupt(const Vector<String16> &args, int inFd, int outFd);
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001344
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001345 // Parses comma separated clients list and adds them to mWatchedClientPackages.
1346 // Does not acquire mLogLock before modifying mWatchedClientPackages. It is the caller's
1347 // responsibility to acquire mLogLock before calling this function.
1348 void parseClientsToWatchLocked(String8 clients);
1349
Svet Ganova453d0d2018-01-11 15:37:58 -08001350 // Prints the shell command help
1351 status_t printHelp(int out);
1352
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001353 // Returns true if client should monitor tags based on the contents of mWatchedClientPackages.
1354 // Acquires mLogLock before querying mWatchedClientPackages.
1355 bool isClientWatched(const BasicClient *client);
1356
1357 // Returns true if client should monitor tags based on the contents of mWatchedClientPackages.
1358 // Does not acquire mLogLock before querying mWatchedClientPackages. It is the caller's
1359 // responsibility to acquire mLogLock before calling this functions.
1360 bool isClientWatchedLocked(const BasicClient *client);
1361
Ruben Brunkb2119af2014-05-09 19:57:56 -07001362 /**
Ruben Brunkcc776712015-02-17 20:18:47 -08001363 * Get the current system time as a formatted string.
Ruben Brunkb2119af2014-05-09 19:57:56 -07001364 */
Ruben Brunkcc776712015-02-17 20:18:47 -08001365 static String8 getFormattedCurrentTime();
1366
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001367 static binder::Status makeClient(const sp<CameraService>& cameraService,
Philip P. Moltmann9e648f62019-11-04 12:52:45 -08001368 const sp<IInterface>& cameraCb, const String16& packageName,
Jayant Chowdharyeb0169f2022-01-31 00:00:02 -08001369 bool systemNativeClient, const std::optional<String16>& featureId,
1370 const String8& cameraId, int api1CameraId, int facing, int sensorOrientation,
Jayant Chowdharyffc5d682022-05-12 18:34:34 +00001371 int clientPid, uid_t clientUid, int servicePid,
1372 std::pair<int, IPCTransport> deviceVersionAndIPCTransport, apiLevel effectiveApiLevel,
Chengfei Taobe683db2023-01-31 18:52:49 +00001373 bool overrideForPerfClass, bool overrideToPortrait, bool forceSlowJpegMode,
1374 /*out*/sp<BasicClient>* client);
Ruben Brunk6267b532015-04-30 17:44:07 -07001375
1376 status_t checkCameraAccess(const String16& opPackageName);
1377
1378 static String8 toString(std::set<userid_t> intSet);
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001379 static int32_t mapToInterface(TorchModeStatus status);
1380 static StatusInternal mapToInternal(CameraDeviceStatus status);
Eino-Ville Talvalaf51fca22016-12-13 11:25:55 -08001381 static int32_t mapToInterface(StatusInternal status);
Ruben Brunk6267b532015-04-30 17:44:07 -07001382
Ruben Brunk2823ce02015-05-19 17:25:13 -07001383
Shuzhen Wang7d859d42018-11-06 15:33:23 -08001384 void broadcastTorchModeStatus(const String8& cameraId,
Jayant Chowdhary0bd38522021-11-05 17:49:27 -07001385 TorchModeStatus status, SystemCameraKind systemCameraKind);
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001386
Rucha Katakwar38284522021-11-10 11:25:21 -08001387 void broadcastTorchStrengthLevel(const String8& cameraId, int32_t newTorchStrengthLevel);
1388
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001389 void disconnectClient(const String8& id, sp<BasicClient> clientToDisconnect);
1390
1391 // Regular online and offline devices must not be in conflict at camera service layer.
1392 // Use separate keys for offline devices.
1393 static const String8 kOfflineDevice;
1394
Avichal Rakesh7fbc3982021-10-20 04:35:03 -07001395 // Sentinel value to be stored in `mWatchedClientsPackages` to indicate that all clients should
1396 // be watched.
1397 static const String16 kWatchAllClientsFlag;
1398
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001399 // TODO: right now each BasicClient holds one AppOpsManager instance.
1400 // We can refactor the code so all of clients share this instance
1401 AppOpsManager mAppOps;
1402
1403 // Aggreated audio restriction mode for all camera clients
1404 int32_t mAudioRestriction;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001405
Emilian Peev8b64f282021-03-25 16:49:57 -07001406 // Current override cmd rotate-and-crop mode; AUTO means no override
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001407 uint8_t mOverrideRotateAndCropMode = ANDROID_SCALER_ROTATE_AND_CROP_AUTO;
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001408
Bharatt Kukreja7146ced2022-10-25 15:45:29 +00001409 // Current autoframing mode
1410 uint8_t mOverrideAutoframingMode = ANDROID_CONTROL_AUTOFRAMING_AUTO;
1411
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001412 // Current image dump mask
1413 uint8_t mImageDumpMask = 0;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001414
1415 // Current camera mute mode
1416 bool mOverrideCameraMuteMode = false;
Cliff Wud8cae102021-03-11 01:37:42 +08001417
Ravneetaeb20dc2022-03-30 05:33:03 +00001418 // Camera Service watchdog flag
1419 bool mCameraServiceWatchdogEnabled = true;
1420
Shuzhen Wang16610a62022-12-15 22:38:07 -08001421 // Current stream use case overrides
1422 std::vector<int64_t> mStreamUseCaseOverrides;
1423
Shuzhen Wangaf22e912023-04-11 16:03:17 -07001424 // Current zoom override value
1425 int32_t mZoomOverrideValue = -1;
1426
Cliff Wud8cae102021-03-11 01:37:42 +08001427 /**
1428 * A listener class that implements the IBinder::DeathRecipient interface
1429 * for use to call back the error state injected by the external camera, and
1430 * camera service can kill the injection when binder signals process death.
1431 */
1432 class InjectionStatusListener : public virtual IBinder::DeathRecipient {
1433 public:
1434 InjectionStatusListener(sp<CameraService> parent) : mParent(parent) {}
1435
1436 void addListener(const sp<hardware::camera2::ICameraInjectionCallback>& callback);
1437 void removeListener();
Cliff Wud3a05312021-04-26 23:07:31 +08001438 void notifyInjectionError(String8 injectedCamId, status_t err);
Cliff Wud8cae102021-03-11 01:37:42 +08001439
1440 // IBinder::DeathRecipient implementation
1441 virtual void binderDied(const wp<IBinder>& who);
1442
1443 private:
1444 Mutex mListenerLock;
1445 wp<CameraService> mParent;
1446 sp<hardware::camera2::ICameraInjectionCallback> mCameraInjectionCallback;
1447 };
1448
1449 sp<InjectionStatusListener> mInjectionStatusListener;
1450
1451 /**
1452 * A class that implements the hardware::camera2::BnCameraInjectionSession interface
1453 */
1454 class CameraInjectionSession : public hardware::camera2::BnCameraInjectionSession {
1455 public:
1456 CameraInjectionSession(sp<CameraService> parent) : mParent(parent) {}
1457 virtual ~CameraInjectionSession() {}
1458 binder::Status stopInjection() override;
1459
1460 private:
1461 Mutex mInjectionSessionLock;
1462 wp<CameraService> mParent;
1463 };
1464
Cliff Wu646bd612021-11-23 23:21:29 +08001465 // When injecting the camera, it will check whether the injecting camera status is unavailable.
1466 // If it is, the disconnect function will be called to to prevent camera access on the device.
1467 status_t checkIfInjectionCameraIsPresent(const String8& externalCamId,
1468 sp<BasicClient> clientSp);
1469
Cliff Wud3a05312021-04-26 23:07:31 +08001470 void clearInjectionParameters();
1471
1472 // This is the existing camera id being replaced.
1473 String8 mInjectionInternalCamId;
1474 // This is the external camera Id replacing the internalId.
1475 String8 mInjectionExternalCamId;
Cliff Wu646bd612021-11-23 23:21:29 +08001476 bool mInjectionInitPending = false;
Cliff Wud3a05312021-04-26 23:07:31 +08001477 // Guard mInjectionInternalCamId and mInjectionInitPending.
1478 Mutex mInjectionParametersLock;
Rucha Katakwar38284522021-11-10 11:25:21 -08001479
Austin Borger18b30a72022-10-27 12:20:29 -07001480 // Track the folded/unfoled device state. 0 == UNFOLDED, 4 == FOLDED
1481 int64_t mDeviceState;
1482
Rucha Katakwar38284522021-11-10 11:25:21 -08001483 void updateTorchUidMapLocked(const String16& cameraId, int uid);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001484};
1485
Mathias Agopian65ab4712010-07-14 17:59:35 -07001486} // namespace android
1487
1488#endif