blob: 457c79b2aa456bbf4b54488c49341d6caae6d63b [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
2**
3** Copyright (C) 2008, The Android Open Source Project
Mathias Agopian65ab4712010-07-14 17:59:35 -07004**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
19#define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
20
Mathias Agopian5462fc92010-07-14 18:41:18 -070021#include <binder/BinderService.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070022#include <camera/ICameraService.h>
Iliyan Malchev8951a972011-04-14 16:55:59 -070023#include <hardware/camera.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070024
25/* This needs to be increased if we can have more cameras */
26#define MAX_CAMERAS 2
27
28namespace android {
29
30class MemoryHeapBase;
31class MediaPlayer;
Iliyan Malchev8951a972011-04-14 16:55:59 -070032class CameraHardwareInterface;
Mathias Agopian65ab4712010-07-14 17:59:35 -070033
Mathias Agopian5462fc92010-07-14 18:41:18 -070034class CameraService :
35 public BinderService<CameraService>,
36 public BnCameraService
Mathias Agopian65ab4712010-07-14 17:59:35 -070037{
38 class Client;
Mathias Agopian5462fc92010-07-14 18:41:18 -070039 friend class BinderService<CameraService>;
Mathias Agopian65ab4712010-07-14 17:59:35 -070040public:
Mathias Agopian5462fc92010-07-14 18:41:18 -070041 static char const* getServiceName() { return "media.camera"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -070042
43 CameraService();
44 virtual ~CameraService();
45
46 virtual int32_t getNumberOfCameras();
47 virtual status_t getCameraInfo(int cameraId,
48 struct CameraInfo* cameraInfo);
Wu-cheng Li2fd24402012-02-23 19:01:00 -080049 virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient, int cameraId,
50 bool force, bool keep);
Mathias Agopian65ab4712010-07-14 17:59:35 -070051 virtual void removeClient(const sp<ICameraClient>& cameraClient);
52 virtual sp<Client> getClientById(int cameraId);
53
54 virtual status_t dump(int fd, const Vector<String16>& args);
55 virtual status_t onTransact(uint32_t code, const Parcel& data,
56 Parcel* reply, uint32_t flags);
Iliyan Malchev8951a972011-04-14 16:55:59 -070057 virtual void onFirstRef();
Mathias Agopian65ab4712010-07-14 17:59:35 -070058
59 enum sound_kind {
60 SOUND_SHUTTER = 0,
61 SOUND_RECORDING = 1,
62 NUM_SOUNDS
63 };
64
65 void loadSound();
66 void playSound(sound_kind kind);
67 void releaseSound();
68
69private:
70 Mutex mServiceLock;
71 wp<Client> mClient[MAX_CAMERAS]; // protected by mServiceLock
72 int mNumberOfCameras;
73
74 // atomics to record whether the hardware is allocated to some client.
75 volatile int32_t mBusy[MAX_CAMERAS];
76 void setCameraBusy(int cameraId);
77 void setCameraFree(int cameraId);
78
79 // sounds
Chih-Chung Changff4f55c2011-10-17 19:03:12 +080080 MediaPlayer* newMediaPlayer(const char *file);
81
Mathias Agopian65ab4712010-07-14 17:59:35 -070082 Mutex mSoundLock;
83 sp<MediaPlayer> mSoundPlayer[NUM_SOUNDS];
84 int mSoundRef; // reference count (release all MediaPlayer when 0)
85
86 class Client : public BnCamera
87 {
88 public:
89 // ICamera interface (see ICamera for details)
90 virtual void disconnect();
91 virtual status_t connect(const sp<ICameraClient>& client);
92 virtual status_t lock();
93 virtual status_t unlock();
Jamie Gennis4b791682010-08-10 16:37:53 -070094 virtual status_t setPreviewDisplay(const sp<Surface>& surface);
Jamie Gennisbfa33aa2010-12-20 11:51:31 -080095 virtual status_t setPreviewTexture(const sp<ISurfaceTexture>& surfaceTexture);
Mathias Agopian65ab4712010-07-14 17:59:35 -070096 virtual void setPreviewCallbackFlag(int flag);
97 virtual status_t startPreview();
98 virtual void stopPreview();
99 virtual bool previewEnabled();
James Donge2ad6732010-10-18 20:42:51 -0700100 virtual status_t storeMetaDataInBuffers(bool enabled);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700101 virtual status_t startRecording();
102 virtual void stopRecording();
103 virtual bool recordingEnabled();
104 virtual void releaseRecordingFrame(const sp<IMemory>& mem);
105 virtual status_t autoFocus();
106 virtual status_t cancelAutoFocus();
James Donge468ac52011-02-17 16:38:06 -0800107 virtual status_t takePicture(int msgType);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700108 virtual status_t setParameters(const String8& params);
109 virtual String8 getParameters() const;
110 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
111 private:
112 friend class CameraService;
113 Client(const sp<CameraService>& cameraService,
114 const sp<ICameraClient>& cameraClient,
Wu-cheng Lib7a67942010-08-17 15:45:37 -0700115 const sp<CameraHardwareInterface>& hardware,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700116 int cameraId,
Wu-cheng Lie09591e2010-10-14 20:17:44 +0800117 int cameraFacing,
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800118 int clientPid,
119 bool keep);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700120 ~Client();
121
122 // return our camera client
123 const sp<ICameraClient>& getCameraClient() { return mCameraClient; }
124
125 // check whether the calling process matches mClientPid.
126 status_t checkPid() const;
127 status_t checkPidAndHardware() const; // also check mHardware != 0
128
129 // these are internal functions used to set up preview buffers
130 status_t registerPreviewBuffers();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700131
132 // camera operation mode
133 enum camera_mode {
134 CAMERA_PREVIEW_MODE = 0, // frame automatically released
135 CAMERA_RECORDING_MODE = 1, // frame has to be explicitly released by releaseRecordingFrame()
136 };
137 // these are internal functions used for preview/recording
138 status_t startCameraMode(camera_mode mode);
139 status_t startPreviewMode();
140 status_t startRecordingMode();
141
Nipun Kwatrab5ca4612010-09-11 19:31:10 -0700142 // internal function used by sendCommand to enable/disable shutter sound.
143 status_t enableShutterSound(bool enable);
144
Mathias Agopian65ab4712010-07-14 17:59:35 -0700145 // these are static callback functions
146 static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user);
Wu-cheng Liff09ef82011-07-28 05:30:59 +0800147 static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
148 camera_frame_metadata_t *metadata, void* user);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700149 static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, void* user);
150 // convert client from cookie
151 static sp<Client> getClientFromCookie(void* user);
152 // handlers for messages
Iliyan Malchev108dddf2011-03-28 16:10:12 -0700153 void handleShutter(void);
Wu-cheng Li57c86182011-07-30 05:00:37 +0800154 void handlePreviewData(int32_t msgType, const sp<IMemory>& mem,
155 camera_frame_metadata_t *metadata);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700156 void handlePostview(const sp<IMemory>& mem);
157 void handleRawPicture(const sp<IMemory>& mem);
158 void handleCompressedPicture(const sp<IMemory>& mem);
159 void handleGenericNotify(int32_t msgType, int32_t ext1, int32_t ext2);
Wu-cheng Li57c86182011-07-30 05:00:37 +0800160 void handleGenericData(int32_t msgType, const sp<IMemory>& dataPtr,
161 camera_frame_metadata_t *metadata);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700162 void handleGenericDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
163
164 void copyFrameAndPostCopiedFrame(
Wu-cheng Li57c86182011-07-30 05:00:37 +0800165 int32_t msgType,
Mathias Agopian65ab4712010-07-14 17:59:35 -0700166 const sp<ICameraClient>& client,
167 const sp<IMemoryHeap>& heap,
Wu-cheng Li57c86182011-07-30 05:00:37 +0800168 size_t offset, size_t size,
169 camera_frame_metadata_t *metadata);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700170
Wu-cheng Lie09591e2010-10-14 20:17:44 +0800171 int getOrientation(int orientation, bool mirror);
172
Jamie Gennis0ed3ec02011-07-13 15:13:14 -0700173 status_t setPreviewWindow(
174 const sp<IBinder>& binder,
175 const sp<ANativeWindow>& window);
176
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800177 void disconnectInternal(bool needCheckPid);
178 bool keep() const;
179 void waitRelease(int ms);
180
181
Mathias Agopian65ab4712010-07-14 17:59:35 -0700182 // these are initialized in the constructor.
183 sp<CameraService> mCameraService; // immutable after constructor
184 sp<ICameraClient> mCameraClient;
185 int mCameraId; // immutable after constructor
Wu-cheng Li012716a2010-10-08 22:04:43 +0800186 int mCameraFacing; // immutable after constructor
Mathias Agopian65ab4712010-07-14 17:59:35 -0700187 pid_t mClientPid;
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800188 // Client wants to keep the camera from taking by other clients.
189 bool mKeep;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700190 sp<CameraHardwareInterface> mHardware; // cleared after disconnect()
Mathias Agopian65ab4712010-07-14 17:59:35 -0700191 int mPreviewCallbackFlag;
Wu-cheng Li4a73f3d2010-09-23 17:17:43 -0700192 int mOrientation; // Current display orientation
Nipun Kwatrab5ca4612010-09-11 19:31:10 -0700193 bool mPlayShutterSound;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700194
195 // Ensures atomicity among the public methods
196 mutable Mutex mLock;
Wu-cheng Li2fd24402012-02-23 19:01:00 -0800197 // This will get notified when the hardware is released.
198 Condition mReleaseCondition;
Jamie Gennisbfa33aa2010-12-20 11:51:31 -0800199 // This is a binder of Surface or SurfaceTexture.
200 sp<IBinder> mSurface;
Jamie Gennis4b791682010-08-10 16:37:53 -0700201 sp<ANativeWindow> mPreviewWindow;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700202
203 // If the user want us to return a copy of the preview frame (instead
204 // of the original one), we allocate mPreviewBuffer and reuse it if possible.
205 sp<MemoryHeapBase> mPreviewBuffer;
206
207 // We need to avoid the deadlock when the incoming command thread and
208 // the CameraHardwareInterface callback thread both want to grab mLock.
209 // An extra flag is used to tell the callback thread that it should stop
210 // trying to deliver the callback messages if the client is not
211 // interested in it anymore. For example, if the client is calling
212 // stopPreview(), the preview frame messages do not need to be delivered
213 // anymore.
214
215 // This function takes the same parameter as the enableMsgType() and
216 // disableMsgType() functions in CameraHardwareInterface.
217 void enableMsgType(int32_t msgType);
218 void disableMsgType(int32_t msgType);
219 volatile int32_t mMsgEnabled;
220
221 // This function keeps trying to grab mLock, or give up if the message
222 // is found to be disabled. It returns true if mLock is grabbed.
223 bool lockIfMessageWanted(int32_t msgType);
224 };
Iliyan Malchev8951a972011-04-14 16:55:59 -0700225
226 camera_module_t *mModule;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700227};
228
229} // namespace android
230
231#endif