1 /*
2 * 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 */
16
17 #ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
18 #define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
19
20 #include <cutils/multiuser.h>
21 #include <utils/Vector.h>
22 #include <utils/KeyedVector.h>
23 #include <binder/AppOpsManager.h>
24 #include <binder/BinderService.h>
25 #include <binder/IAppOpsCallback.h>
26 #include <camera/ICameraService.h>
27 #include <hardware/camera.h>
28
29 #include <camera/ICamera.h>
30 #include <camera/ICameraClient.h>
31 #include <camera/camera2/ICameraDeviceUser.h>
32 #include <camera/camera2/ICameraDeviceCallbacks.h>
33 #include <camera/VendorTagDescriptor.h>
34 #include <camera/CaptureResult.h>
35 #include <camera/CameraParameters.h>
36
37 #include <camera/ICameraServiceListener.h>
38 #include "CameraFlashlight.h"
39
40 #include "common/CameraModule.h"
41 #include "media/RingBuffer.h"
42 #include "utils/AutoConditionLock.h"
43 #include "utils/ClientManager.h"
44
45 #include <set>
46 #include <string>
47 #include <map>
48 #include <memory>
49 #include <utility>
50
51 namespace android {
52
53 extern volatile int32_t gLogLevel;
54
55 class MemoryHeapBase;
56 class MediaPlayer;
57
58 class CameraService :
59 public BinderService<CameraService>,
60 public BnCameraService,
61 public IBinder::DeathRecipient,
62 public camera_module_callbacks_t
63 {
64 friend class BinderService<CameraService>;
65 public:
66 class Client;
67 class BasicClient;
68
69 // The effective API level. The Camera2 API running in LEGACY mode counts as API_1.
70 enum apiLevel {
71 API_1 = 1,
72 API_2 = 2
73 };
74
75 // Process state (mirrors frameworks/base/core/java/android/app/ActivityManager.java)
76 static const int PROCESS_STATE_NONEXISTENT = -1;
77
78 // 3 second busy timeout when other clients are connecting
79 static const nsecs_t DEFAULT_CONNECT_TIMEOUT_NS = 3000000000;
80
81 // 1 second busy timeout when other clients are disconnecting
82 static const nsecs_t DEFAULT_DISCONNECT_TIMEOUT_NS = 1000000000;
83
84 // Default number of messages to store in eviction log
85 static const size_t DEFAULT_EVENT_LOG_LENGTH = 100;
86
87 // Implementation of BinderService<T>
getServiceName()88 static char const* getServiceName() { return "media.camera"; }
89
90 CameraService();
91 virtual ~CameraService();
92
93 /////////////////////////////////////////////////////////////////////
94 // HAL Callbacks
95 virtual void onDeviceStatusChanged(camera_device_status_t cameraId,
96 camera_device_status_t newStatus);
97 virtual void onTorchStatusChanged(const String8& cameraId,
98 ICameraServiceListener::TorchStatus
99 newStatus);
100
101 /////////////////////////////////////////////////////////////////////
102 // ICameraService
103 virtual int32_t getNumberOfCameras(int type);
104 virtual int32_t getNumberOfCameras();
105
106 virtual status_t getCameraInfo(int cameraId,
107 struct CameraInfo* cameraInfo);
108 virtual status_t getCameraCharacteristics(int cameraId,
109 CameraMetadata* cameraInfo);
110 virtual status_t getCameraVendorTagDescriptor(/*out*/ sp<VendorTagDescriptor>& desc);
111
112 virtual status_t connect(const sp<ICameraClient>& cameraClient, int cameraId,
113 const String16& clientPackageName, int clientUid,
114 /*out*/
115 sp<ICamera>& device);
116
117 virtual status_t connectLegacy(const sp<ICameraClient>& cameraClient, int cameraId,
118 int halVersion, const String16& clientPackageName, int clientUid,
119 /*out*/
120 sp<ICamera>& device);
121
122 virtual status_t connectDevice(
123 const sp<ICameraDeviceCallbacks>& cameraCb,
124 int cameraId,
125 const String16& clientPackageName,
126 int clientUid,
127 /*out*/
128 sp<ICameraDeviceUser>& device);
129
130 virtual status_t addListener(const sp<ICameraServiceListener>& listener);
131 virtual status_t removeListener(
132 const sp<ICameraServiceListener>& listener);
133
134 virtual status_t getLegacyParameters(
135 int cameraId,
136 /*out*/
137 String16* parameters);
138
139 virtual status_t setTorchMode(const String16& cameraId, bool enabled,
140 const sp<IBinder>& clientBinder);
141
142 virtual void notifySystemEvent(int32_t eventId, const int32_t* args, size_t length);
143
144 // OK = supports api of that version, -EOPNOTSUPP = does not support
145 virtual status_t supportsCameraApi(
146 int cameraId, int apiVersion);
147
148 // Extra permissions checks
149 virtual status_t onTransact(uint32_t code, const Parcel& data,
150 Parcel* reply, uint32_t flags);
151
152 virtual status_t dump(int fd, const Vector<String16>& args);
153
154 /////////////////////////////////////////////////////////////////////
155 // Client functionality
156
157 enum sound_kind {
158 SOUND_SHUTTER = 0,
159 SOUND_RECORDING = 1,
160 NUM_SOUNDS
161 };
162
163 void loadSound();
164 void playSound(sound_kind kind);
165 void releaseSound();
166
167 /////////////////////////////////////////////////////////////////////
168 // CameraDeviceFactory functionality
169 int getDeviceVersion(int cameraId, int* facing = NULL);
170
171 /////////////////////////////////////////////////////////////////////
172 // Shared utilities
173 static status_t filterGetInfoErrorCode(status_t err);
174
175 /////////////////////////////////////////////////////////////////////
176 // CameraClient functionality
177
178 class BasicClient : public virtual RefBase {
179 public:
180 virtual status_t initialize(CameraModule *module) = 0;
181 virtual void disconnect();
182
183 // because we can't virtually inherit IInterface, which breaks
184 // virtual inheritance
185 virtual sp<IBinder> asBinderWrapper() = 0;
186
187 // Return the remote callback binder object (e.g. ICameraDeviceCallbacks)
getRemote()188 sp<IBinder> getRemote() {
189 return mRemoteBinder;
190 }
191
192 virtual status_t dump(int fd, const Vector<String16>& args) = 0;
193
194 // Return the package name for this client
195 virtual String16 getPackageName() const;
196
197 // Notify client about a fatal error
198 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
199 const CaptureResultExtras& resultExtras) = 0;
200
201 // Get the UID of the application client using this
202 virtual uid_t getClientUid() const;
203
204 // Get the PID of the application client using this
205 virtual int getClientPid() const;
206
207 // Check what API level is used for this client. This is used to determine which
208 // superclass this can be cast to.
209 virtual bool canCastToApiClient(apiLevel level) const;
210 protected:
211 BasicClient(const sp<CameraService>& cameraService,
212 const sp<IBinder>& remoteCallback,
213 const String16& clientPackageName,
214 int cameraId,
215 int cameraFacing,
216 int clientPid,
217 uid_t clientUid,
218 int servicePid);
219
220 virtual ~BasicClient();
221
222 // the instance is in the middle of destruction. When this is set,
223 // the instance should not be accessed from callback.
224 // CameraService's mClientLock should be acquired to access this.
225 // - subclasses should set this to true in their destructors.
226 bool mDestructionStarted;
227
228 // these are initialized in the constructor.
229 sp<CameraService> mCameraService; // immutable after constructor
230 int mCameraId; // immutable after constructor
231 int mCameraFacing; // immutable after constructor
232 const String16 mClientPackageName;
233 pid_t mClientPid;
234 uid_t mClientUid; // immutable after constructor
235 pid_t mServicePid; // immutable after constructor
236 bool mDisconnected;
237
238 // - The app-side Binder interface to receive callbacks from us
239 sp<IBinder> mRemoteBinder; // immutable after constructor
240
241 // permissions management
242 status_t startCameraOps();
243 status_t finishCameraOps();
244
245 private:
246 AppOpsManager mAppOpsManager;
247
248 class OpsCallback : public BnAppOpsCallback {
249 public:
250 OpsCallback(wp<BasicClient> client);
251 virtual void opChanged(int32_t op, const String16& packageName);
252
253 private:
254 wp<BasicClient> mClient;
255
256 }; // class OpsCallback
257
258 sp<OpsCallback> mOpsCallback;
259 // Track whether startCameraOps was called successfully, to avoid
260 // finishing what we didn't start.
261 bool mOpsActive;
262
263 // IAppOpsCallback interface, indirected through opListener
264 virtual void opChanged(int32_t op, const String16& packageName);
265 }; // class BasicClient
266
267 class Client : public BnCamera, public BasicClient
268 {
269 public:
270 typedef ICameraClient TCamCallbacks;
271
272 // ICamera interface (see ICamera for details)
273 virtual void disconnect();
274 virtual status_t connect(const sp<ICameraClient>& client) = 0;
275 virtual status_t lock() = 0;
276 virtual status_t unlock() = 0;
277 virtual status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)=0;
278 virtual void setPreviewCallbackFlag(int flag) = 0;
279 virtual status_t setPreviewCallbackTarget(
280 const sp<IGraphicBufferProducer>& callbackProducer) = 0;
281 virtual status_t startPreview() = 0;
282 virtual void stopPreview() = 0;
283 virtual bool previewEnabled() = 0;
284 virtual status_t storeMetaDataInBuffers(bool enabled) = 0;
285 virtual status_t startRecording() = 0;
286 virtual void stopRecording() = 0;
287 virtual bool recordingEnabled() = 0;
288 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0;
289 virtual status_t autoFocus() = 0;
290 virtual status_t cancelAutoFocus() = 0;
291 virtual status_t takePicture(int msgType) = 0;
292 virtual status_t setParameters(const String8& params) = 0;
293 virtual String8 getParameters() const = 0;
294 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;
295
296 // Interface used by CameraService
297 Client(const sp<CameraService>& cameraService,
298 const sp<ICameraClient>& cameraClient,
299 const String16& clientPackageName,
300 int cameraId,
301 int cameraFacing,
302 int clientPid,
303 uid_t clientUid,
304 int servicePid);
305 ~Client();
306
307 // return our camera client
getRemoteCallback()308 const sp<ICameraClient>& getRemoteCallback() {
309 return mRemoteCallback;
310 }
311
asBinderWrapper()312 virtual sp<IBinder> asBinderWrapper() {
313 return asBinder(this);
314 }
315
316 virtual void notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
317 const CaptureResultExtras& resultExtras);
318
319 // Check what API level is used for this client. This is used to determine which
320 // superclass this can be cast to.
321 virtual bool canCastToApiClient(apiLevel level) const;
322 protected:
323 // Convert client from cookie.
324 static sp<CameraService::Client> getClientFromCookie(void* user);
325
326 // Initialized in constructor
327
328 // - The app-side Binder interface to receive callbacks from us
329 sp<ICameraClient> mRemoteCallback;
330
331 }; // class Client
332
333 /**
334 * A listener class that implements the LISTENER interface for use with a ClientManager, and
335 * implements the following methods:
336 * void onClientRemoved(const ClientDescriptor<KEY, VALUE>& descriptor);
337 * void onClientAdded(const ClientDescriptor<KEY, VALUE>& descriptor);
338 */
339 class ClientEventListener {
340 public:
341 void onClientAdded(const resource_policy::ClientDescriptor<String8,
342 sp<CameraService::BasicClient>>& descriptor);
343 void onClientRemoved(const resource_policy::ClientDescriptor<String8,
344 sp<CameraService::BasicClient>>& descriptor);
345 }; // class ClientEventListener
346
347 typedef std::shared_ptr<resource_policy::ClientDescriptor<String8,
348 sp<CameraService::BasicClient>>> DescriptorPtr;
349
350 /**
351 * A container class for managing active camera clients that are using HAL devices. Active
352 * clients are represented by ClientDescriptor objects that contain strong pointers to the
353 * actual BasicClient subclass binder interface implementation.
354 *
355 * This class manages the eviction behavior for the camera clients. See the parent class
356 * implementation in utils/ClientManager for the specifics of this behavior.
357 */
358 class CameraClientManager : public resource_policy::ClientManager<String8,
359 sp<CameraService::BasicClient>, ClientEventListener> {
360 public:
361 CameraClientManager();
362 virtual ~CameraClientManager();
363
364 /**
365 * Return a strong pointer to the active BasicClient for this camera ID, or an empty
366 * if none exists.
367 */
368 sp<CameraService::BasicClient> getCameraClient(const String8& id) const;
369
370 /**
371 * Return a string describing the current state.
372 */
373 String8 toString() const;
374
375 /**
376 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer.
377 */
378 static DescriptorPtr makeClientDescriptor(const String8& key, const sp<BasicClient>& value,
379 int32_t cost, const std::set<String8>& conflictingKeys, int32_t priority,
380 int32_t ownerId);
381
382 /**
383 * Make a ClientDescriptor object wrapping the given BasicClient strong pointer with
384 * values intialized from a prior ClientDescriptor.
385 */
386 static DescriptorPtr makeClientDescriptor(const sp<BasicClient>& value,
387 const CameraService::DescriptorPtr& partial);
388
389 }; // class CameraClientManager
390
391 private:
392
393 /**
394 * Container class for the state of each logical camera device, including: ID, status, and
395 * dependencies on other devices. The mapping of camera ID -> state saved in mCameraStates
396 * represents the camera devices advertised by the HAL (and any USB devices, when we add
397 * those).
398 *
399 * This container does NOT represent an active camera client. These are represented using
400 * the ClientDescriptors stored in mActiveClientManager.
401 */
402 class CameraState {
403 public:
404 /**
405 * Make a new CameraState and set the ID, cost, and conflicting devices using the values
406 * returned in the HAL's camera_info struct for each device.
407 */
408 CameraState(const String8& id, int cost, const std::set<String8>& conflicting);
409 virtual ~CameraState();
410
411 /**
412 * Return the status for this device.
413 *
414 * This method acquires mStatusLock.
415 */
416 ICameraServiceListener::Status getStatus() const;
417
418 /**
419 * This function updates the status for this camera device, unless the given status
420 * is in the given list of rejected status states, and execute the function passed in
421 * with a signature onStatusUpdateLocked(const String8&, ICameraServiceListener::Status)
422 * if the status has changed.
423 *
424 * This method is idempotent, and will not result in the function passed to
425 * onStatusUpdateLocked being called more than once for the same arguments.
426 * This method aquires mStatusLock.
427 */
428 template<class Func>
429 void updateStatus(ICameraServiceListener::Status status, const String8& cameraId,
430 std::initializer_list<ICameraServiceListener::Status> rejectSourceStates,
431 Func onStatusUpdatedLocked);
432
433 /**
434 * Return the last set CameraParameters object generated from the information returned by
435 * the HAL for this device (or an empty CameraParameters object if none has been set).
436 */
437 CameraParameters getShimParams() const;
438
439 /**
440 * Set the CameraParameters for this device.
441 */
442 void setShimParams(const CameraParameters& params);
443
444 /**
445 * Return the resource_cost advertised by the HAL for this device.
446 */
447 int getCost() const;
448
449 /**
450 * Return a set of the IDs of conflicting devices advertised by the HAL for this device.
451 */
452 std::set<String8> getConflicting() const;
453
454 /**
455 * Return the ID of this camera device.
456 */
457 String8 getId() const;
458
459 private:
460 const String8 mId;
461 ICameraServiceListener::Status mStatus; // protected by mStatusLock
462 const int mCost;
463 std::set<String8> mConflicting;
464 mutable Mutex mStatusLock;
465 CameraParameters mShimParams;
466 }; // class CameraState
467
468 // Delay-load the Camera HAL module
469 virtual void onFirstRef();
470
471 // Check if we can connect, before we acquire the service lock.
472 status_t validateConnectLocked(const String8& cameraId, /*inout*/int& clientUid) const;
473
474 // Handle active client evictions, and update service state.
475 // Only call with with mServiceLock held.
476 status_t handleEvictionsLocked(const String8& cameraId, int clientPid,
477 apiLevel effectiveApiLevel, const sp<IBinder>& remoteCallback, const String8& packageName,
478 /*out*/
479 sp<BasicClient>* client,
480 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>>* partial);
481
482 // Single implementation shared between the various connect calls
483 template<class CALLBACK, class CLIENT>
484 status_t connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId, int halVersion,
485 const String16& clientPackageName, int clientUid, apiLevel effectiveApiLevel,
486 bool legacyMode, bool shimUpdateOnly, /*out*/sp<CLIENT>& device);
487
488 // Lock guarding camera service state
489 Mutex mServiceLock;
490
491 // Condition to use with mServiceLock, used to handle simultaneous connect calls from clients
492 std::shared_ptr<WaitableMutexWrapper> mServiceLockWrapper;
493
494 // Return NO_ERROR if the device with a give ID can be connected to
495 status_t checkIfDeviceIsUsable(const String8& cameraId) const;
496
497 // Container for managing currently active application-layer clients
498 CameraClientManager mActiveClientManager;
499
500 // Mapping from camera ID -> state for each device, map is protected by mCameraStatesLock
501 std::map<String8, std::shared_ptr<CameraState>> mCameraStates;
502
503 // Mutex guarding mCameraStates map
504 mutable Mutex mCameraStatesLock;
505
506 // Circular buffer for storing event logging for dumps
507 RingBuffer<String8> mEventLog;
508 Mutex mLogLock;
509
510 // Currently allowed user IDs
511 std::set<userid_t> mAllowedUsers;
512
513 /**
514 * Check camera capabilities, such as support for basic color operation
515 */
516 int checkCameraCapabilities(int id, camera_info info, int *latestStrangeCameraId);
517
518 /**
519 * Get the camera state for a given camera id.
520 *
521 * This acquires mCameraStatesLock.
522 */
523 std::shared_ptr<CameraService::CameraState> getCameraState(const String8& cameraId) const;
524
525 /**
526 * Evict client who's remote binder has died. Returns true if this client was in the active
527 * list and was disconnected.
528 *
529 * This method acquires mServiceLock.
530 */
531 bool evictClientIdByRemote(const wp<IBinder>& cameraClient);
532
533 /**
534 * Remove the given client from the active clients list; does not disconnect the client.
535 *
536 * This method acquires mServiceLock.
537 */
538 void removeByClient(const BasicClient* client);
539
540 /**
541 * Add new client to active clients list after conflicting clients have disconnected using the
542 * values set in the partial descriptor passed in to construct the actual client descriptor.
543 * This is typically called at the end of a connect call.
544 *
545 * This method must be called with mServiceLock held.
546 */
547 void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc);
548
549 /**
550 * Returns the integer corresponding to the given camera ID string, or -1 on failure.
551 */
552 static int cameraIdToInt(const String8& cameraId);
553
554 /**
555 * Remove a single client corresponding to the given camera id from the list of active clients.
556 * If none exists, return an empty strongpointer.
557 *
558 * This method must be called with mServiceLock held.
559 */
560 sp<CameraService::BasicClient> removeClientLocked(const String8& cameraId);
561
562 /**
563 * Handle a notification that the current device user has changed.
564 */
565 void doUserSwitch(const int32_t* newUserId, size_t length);
566
567 /**
568 * Add an event log message.
569 */
570 void logEvent(const char* event);
571
572 /**
573 * Add an event log message that a client has been disconnected.
574 */
575 void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage);
576
577 /**
578 * Add an event log message that a client has been connected.
579 */
580 void logConnected(const char* cameraId, int clientPid, const char* clientPackage);
581
582 /**
583 * Add an event log message that a client's connect attempt has been rejected.
584 */
585 void logRejected(const char* cameraId, int clientPid, const char* clientPackage,
586 const char* reason);
587
588 /**
589 * Add an event log message that the current device user has been switched.
590 */
591 void logUserSwitch(const std::set<userid_t>& oldUserIds,
592 const std::set<userid_t>& newUserIds);
593
594 /**
595 * Add an event log message that a device has been removed by the HAL
596 */
597 void logDeviceRemoved(const char* cameraId, const char* reason);
598
599 /**
600 * Add an event log message that a device has been added by the HAL
601 */
602 void logDeviceAdded(const char* cameraId, const char* reason);
603
604 /**
605 * Add an event log message that a client has unexpectedly died.
606 */
607 void logClientDied(int clientPid, const char* reason);
608
609 /**
610 * Add a event log message that a serious service-level error has occured
611 */
612 void logServiceError(const char* msg, int errorCode);
613
614 /**
615 * Dump the event log to an FD
616 */
617 void dumpEventLog(int fd);
618
619 int mNumberOfCameras;
620 int mNumberOfNormalCameras;
621
622 // sounds
623 MediaPlayer* newMediaPlayer(const char *file);
624
625 Mutex mSoundLock;
626 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS];
627 int mSoundRef; // reference count (release all MediaPlayer when 0)
628
629 CameraModule* mModule;
630
631 // Guarded by mStatusListenerMutex
632 std::vector<sp<ICameraServiceListener>> mListenerList;
633 Mutex mStatusListenerLock;
634
635 /**
636 * Update the status for the given camera id (if that device exists), and broadcast the
637 * status update to all current ICameraServiceListeners if the status has changed. Any
638 * statuses in rejectedSourceStates will be ignored.
639 *
640 * This method must be idempotent.
641 * This method acquires mStatusLock and mStatusListenerLock.
642 */
643 void updateStatus(ICameraServiceListener::Status status, const String8& cameraId,
644 std::initializer_list<ICameraServiceListener::Status> rejectedSourceStates);
645 void updateStatus(ICameraServiceListener::Status status, const String8& cameraId);
646
647 // flashlight control
648 sp<CameraFlashlight> mFlashlight;
649 // guard mTorchStatusMap
650 Mutex mTorchStatusMutex;
651 // guard mTorchClientMap
652 Mutex mTorchClientMapMutex;
653 // guard mTorchUidMap
654 Mutex mTorchUidMapMutex;
655 // camera id -> torch status
656 KeyedVector<String8, ICameraServiceListener::TorchStatus> mTorchStatusMap;
657 // camera id -> torch client binder
658 // only store the last client that turns on each camera's torch mode
659 KeyedVector<String8, sp<IBinder>> mTorchClientMap;
660 // camera id -> [incoming uid, current uid] pair
661 std::map<String8, std::pair<int, int>> mTorchUidMap;
662
663 // check and handle if torch client's process has died
664 void handleTorchClientBinderDied(const wp<IBinder> &who);
665
666 // handle torch mode status change and invoke callbacks. mTorchStatusMutex
667 // should be locked.
668 void onTorchStatusChangedLocked(const String8& cameraId,
669 ICameraServiceListener::TorchStatus newStatus);
670
671 // get a camera's torch status. mTorchStatusMutex should be locked.
672 status_t getTorchStatusLocked(const String8 &cameraId,
673 ICameraServiceListener::TorchStatus *status) const;
674
675 // set a camera's torch status. mTorchStatusMutex should be locked.
676 status_t setTorchStatusLocked(const String8 &cameraId,
677 ICameraServiceListener::TorchStatus status);
678
679 // IBinder::DeathRecipient implementation
680 virtual void binderDied(const wp<IBinder> &who);
681
682 // Helpers
683
684 bool setUpVendorTags();
685
686 /**
687 * Initialize and cache the metadata used by the HAL1 shim for a given cameraId.
688 *
689 * Returns OK on success, or a negative error code.
690 */
691 status_t initializeShimMetadata(int cameraId);
692
693 /**
694 * Get the cached CameraParameters for the camera. If they haven't been
695 * cached yet, then initialize them for the first time.
696 *
697 * Returns OK on success, or a negative error code.
698 */
699 status_t getLegacyParametersLazy(int cameraId, /*out*/CameraParameters* parameters);
700
701 /**
702 * Generate the CameraCharacteristics metadata required by the Camera2 API
703 * from the available HAL1 CameraParameters and CameraInfo.
704 *
705 * Returns OK on success, or a negative error code.
706 */
707 status_t generateShimMetadata(int cameraId, /*out*/CameraMetadata* cameraInfo);
708
709 static int getCallingPid();
710
711 static int getCallingUid();
712
713 /**
714 * Get the current system time as a formatted string.
715 */
716 static String8 getFormattedCurrentTime();
717
718 /**
719 * Get the camera eviction priority from the current process state given by ActivityManager.
720 */
721 static int getCameraPriorityFromProcState(int procState);
722
723 static status_t makeClient(const sp<CameraService>& cameraService,
724 const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
725 int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
726 int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
727 /*out*/sp<BasicClient>* client);
728
729 status_t checkCameraAccess(const String16& opPackageName);
730
731 static String8 toString(std::set<userid_t> intSet);
732
733 static void pingCameraServiceProxy();
734
735 };
736
737 template<class Func>
updateStatus(ICameraServiceListener::Status status,const String8 & cameraId,std::initializer_list<ICameraServiceListener::Status> rejectSourceStates,Func onStatusUpdatedLocked)738 void CameraService::CameraState::updateStatus(ICameraServiceListener::Status status,
739 const String8& cameraId,
740 std::initializer_list<ICameraServiceListener::Status> rejectSourceStates,
741 Func onStatusUpdatedLocked) {
742 Mutex::Autolock lock(mStatusLock);
743 ICameraServiceListener::Status oldStatus = mStatus;
744 mStatus = status;
745
746 if (oldStatus == status) {
747 return;
748 }
749
750 ALOGV("%s: Status has changed for camera ID %s from %#x to %#x", __FUNCTION__,
751 cameraId.string(), oldStatus, status);
752
753 if (oldStatus == ICameraServiceListener::STATUS_NOT_PRESENT &&
754 (status != ICameraServiceListener::STATUS_PRESENT &&
755 status != ICameraServiceListener::STATUS_ENUMERATING)) {
756
757 ALOGW("%s: From NOT_PRESENT can only transition into PRESENT or ENUMERATING",
758 __FUNCTION__);
759 mStatus = oldStatus;
760 return;
761 }
762
763 /**
764 * Sometimes we want to conditionally do a transition.
765 * For example if a client disconnects, we want to go to PRESENT
766 * only if we weren't already in NOT_PRESENT or ENUMERATING.
767 */
768 for (auto& rejectStatus : rejectSourceStates) {
769 if (oldStatus == rejectStatus) {
770 ALOGV("%s: Rejecting status transition for Camera ID %s, since the source "
771 "state was was in one of the bad states.", __FUNCTION__, cameraId.string());
772 mStatus = oldStatus;
773 return;
774 }
775 }
776
777 onStatusUpdatedLocked(cameraId, status);
778 }
779
780
781 template<class CALLBACK, class CLIENT>
connectHelper(const sp<CALLBACK> & cameraCb,const String8 & cameraId,int halVersion,const String16 & clientPackageName,int clientUid,apiLevel effectiveApiLevel,bool legacyMode,bool shimUpdateOnly,sp<CLIENT> & device)782 status_t CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,
783 int halVersion, const String16& clientPackageName, int clientUid,
784 apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
785 /*out*/sp<CLIENT>& device) {
786 status_t ret = NO_ERROR;
787 String8 clientName8(clientPackageName);
788 int clientPid = getCallingPid();
789
790 ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
791 "Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
792 (halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
793 static_cast<int>(effectiveApiLevel));
794
795 sp<CLIENT> client = nullptr;
796 {
797 // Acquire mServiceLock and prevent other clients from connecting
798 std::unique_ptr<AutoConditionLock> lock =
799 AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
800
801 if (lock == nullptr) {
802 ALOGE("CameraService::connect X (PID %d) rejected (too many other clients connecting)."
803 , clientPid);
804 return -EBUSY;
805 }
806
807 // Enforce client permissions and do basic sanity checks
808 if((ret = validateConnectLocked(cameraId, /*inout*/clientUid)) != NO_ERROR) {
809 return ret;
810 }
811
812 // Check the shim parameters after acquiring lock, if they have already been updated and
813 // we were doing a shim update, return immediately
814 if (shimUpdateOnly) {
815 auto cameraState = getCameraState(cameraId);
816 if (cameraState != nullptr) {
817 if (!cameraState->getShimParams().isEmpty()) return NO_ERROR;
818 }
819 }
820
821 sp<BasicClient> clientTmp = nullptr;
822 std::shared_ptr<resource_policy::ClientDescriptor<String8, sp<BasicClient>>> partial;
823 if ((ret = handleEvictionsLocked(cameraId, clientPid, effectiveApiLevel,
824 IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
825 /*out*/&partial)) != NO_ERROR) {
826 return ret;
827 }
828
829 if (clientTmp.get() != nullptr) {
830 // Handle special case for API1 MediaRecorder where the existing client is returned
831 device = static_cast<CLIENT*>(clientTmp.get());
832 return NO_ERROR;
833 }
834
835 // give flashlight a chance to close devices if necessary.
836 mFlashlight->prepareDeviceOpen(cameraId);
837
838 // TODO: Update getDeviceVersion + HAL interface to use strings for Camera IDs
839 int id = cameraIdToInt(cameraId);
840 if (id == -1) {
841 ALOGE("%s: Invalid camera ID %s, cannot get device version from HAL.", __FUNCTION__,
842 cameraId.string());
843 return BAD_VALUE;
844 }
845
846 int facing = -1;
847 int deviceVersion = getDeviceVersion(id, /*out*/&facing);
848 sp<BasicClient> tmp = nullptr;
849 if((ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
850 clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
851 /*out*/&tmp)) != NO_ERROR) {
852 return ret;
853 }
854 client = static_cast<CLIENT*>(tmp.get());
855
856 LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
857 __FUNCTION__);
858
859 if ((ret = client->initialize(mModule)) != OK) {
860 ALOGE("%s: Could not initialize client from HAL module.", __FUNCTION__);
861 return ret;
862 }
863
864 sp<IBinder> remoteCallback = client->getRemote();
865 if (remoteCallback != nullptr) {
866 remoteCallback->linkToDeath(this);
867 }
868
869 // Update shim paremeters for legacy clients
870 if (effectiveApiLevel == API_1) {
871 // Assume we have always received a Client subclass for API1
872 sp<Client> shimClient = reinterpret_cast<Client*>(client.get());
873 String8 rawParams = shimClient->getParameters();
874 CameraParameters params(rawParams);
875
876 auto cameraState = getCameraState(cameraId);
877 if (cameraState != nullptr) {
878 cameraState->setShimParams(params);
879 } else {
880 ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
881 __FUNCTION__, cameraId.string());
882 }
883 }
884
885 if (shimUpdateOnly) {
886 // If only updating legacy shim parameters, immediately disconnect client
887 mServiceLock.unlock();
888 client->disconnect();
889 mServiceLock.lock();
890 } else {
891 // Otherwise, add client to active clients list
892 finishConnectLocked(client, partial);
893 }
894 } // lock is destroyed, allow further connect calls
895
896 // Important: release the mutex here so the client can call back into the service from its
897 // destructor (can be at the end of the call)
898 device = client;
899 return NO_ERROR;
900 }
901
902 } // namespace android
903
904 #endif
905