ICamera.cpp revision 3ee3550a2f529cbf56d87d8503f59a8f45dccf32 
1/*
2**
3** Copyright 2008, The Android Open Source Project
4**
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//#define LOG_NDEBUG 0
19#define LOG_TAG "ICamera"
20#include <utils/Log.h>
21#include <stdint.h>
22#include <sys/types.h>
23#include <binder/Parcel.h>
24#include <camera/ICamera.h>
25#include <gui/IGraphicBufferProducer.h>
26#include <gui/Surface.h>
27
28namespace android {
29
30enum {
31    DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
32    SET_PREVIEW_TEXTURE,
33    SET_PREVIEW_CALLBACK_FLAG,
34    SET_PREVIEW_CALLBACK_TARGET,
35    START_PREVIEW,
36    STOP_PREVIEW,
37    AUTO_FOCUS,
38    CANCEL_AUTO_FOCUS,
39    TAKE_PICTURE,
40    SET_PARAMETERS,
41    GET_PARAMETERS,
42    SEND_COMMAND,
43    CONNECT,
44    LOCK,
45    UNLOCK,
46    PREVIEW_ENABLED,
47    START_RECORDING,
48    STOP_RECORDING,
49    RECORDING_ENABLED,
50    RELEASE_RECORDING_FRAME,
51    STORE_META_DATA_IN_BUFFERS,
52};
53
54class BpCamera: public BpInterface<ICamera>
55{
56public:
57    BpCamera(const sp<IBinder>& impl)
58        : BpInterface<ICamera>(impl)
59    {
60    }
61
62    // disconnect from camera service
63    void disconnect()
64    {
65        ALOGV("disconnect");
66        Parcel data, reply;
67        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
68        remote()->transact(DISCONNECT, data, &reply);
69    }
70
71    // pass the buffered IGraphicBufferProducer to the camera service
72    status_t setPreviewTexture(const sp<IGraphicBufferProducer>& bufferProducer)
73    {
74        ALOGV("setPreviewTexture");
75        Parcel data, reply;
76        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
77        sp<IBinder> b(bufferProducer->asBinder());
78        data.writeStrongBinder(b);
79        remote()->transact(SET_PREVIEW_TEXTURE, data, &reply);
80        return reply.readInt32();
81    }
82
83    // set the preview callback flag to affect how the received frames from
84    // preview are handled. See Camera.h for details.
85    void setPreviewCallbackFlag(int flag)
86    {
87        ALOGV("setPreviewCallbackFlag(%d)", flag);
88        Parcel data, reply;
89        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
90        data.writeInt32(flag);
91        remote()->transact(SET_PREVIEW_CALLBACK_FLAG, data, &reply);
92    }
93
94    status_t setPreviewCallbackTarget(
95            const sp<IGraphicBufferProducer>& callbackProducer)
96    {
97        ALOGV("setPreviewCallbackTarget");
98        Parcel data, reply;
99        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
100        sp<IBinder> b(callbackProducer->asBinder());
101        data.writeStrongBinder(b);
102        remote()->transact(SET_PREVIEW_CALLBACK_TARGET, data, &reply);
103        return reply.readInt32();
104    }
105
106    // start preview mode, must call setPreviewDisplay first
107    status_t startPreview()
108    {
109        ALOGV("startPreview");
110        Parcel data, reply;
111        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
112        remote()->transact(START_PREVIEW, data, &reply);
113        return reply.readInt32();
114    }
115
116    // start recording mode, must call setPreviewDisplay first
117    status_t startRecording()
118    {
119        ALOGV("startRecording");
120        Parcel data, reply;
121        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
122        remote()->transact(START_RECORDING, data, &reply);
123        return reply.readInt32();
124    }
125
126    // stop preview mode
127    void stopPreview()
128    {
129        ALOGV("stopPreview");
130        Parcel data, reply;
131        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
132        remote()->transact(STOP_PREVIEW, data, &reply);
133    }
134
135    // stop recording mode
136    void stopRecording()
137    {
138        ALOGV("stopRecording");
139        Parcel data, reply;
140        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
141        remote()->transact(STOP_RECORDING, data, &reply);
142    }
143
144    void releaseRecordingFrame(const sp<IMemory>& mem)
145    {
146        ALOGV("releaseRecordingFrame");
147        Parcel data, reply;
148        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
149        data.writeStrongBinder(mem->asBinder());
150        remote()->transact(RELEASE_RECORDING_FRAME, data, &reply);
151    }
152
153    status_t storeMetaDataInBuffers(bool enabled)
154    {
155        ALOGV("storeMetaDataInBuffers: %s", enabled? "true": "false");
156        Parcel data, reply;
157        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
158        data.writeInt32(enabled);
159        remote()->transact(STORE_META_DATA_IN_BUFFERS, data, &reply);
160        return reply.readInt32();
161    }
162
163    // check preview state
164    bool previewEnabled()
165    {
166        ALOGV("previewEnabled");
167        Parcel data, reply;
168        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
169        remote()->transact(PREVIEW_ENABLED, data, &reply);
170        return reply.readInt32();
171    }
172
173    // check recording state
174    bool recordingEnabled()
175    {
176        ALOGV("recordingEnabled");
177        Parcel data, reply;
178        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
179        remote()->transact(RECORDING_ENABLED, data, &reply);
180        return reply.readInt32();
181    }
182
183    // auto focus
184    status_t autoFocus()
185    {
186        ALOGV("autoFocus");
187        Parcel data, reply;
188        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
189        remote()->transact(AUTO_FOCUS, data, &reply);
190        status_t ret = reply.readInt32();
191        return ret;
192    }
193
194    // cancel focus
195    status_t cancelAutoFocus()
196    {
197        ALOGV("cancelAutoFocus");
198        Parcel data, reply;
199        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
200        remote()->transact(CANCEL_AUTO_FOCUS, data, &reply);
201        status_t ret = reply.readInt32();
202        return ret;
203    }
204
205    // take a picture - returns an IMemory (ref-counted mmap)
206    status_t takePicture(int msgType)
207    {
208        ALOGV("takePicture: 0x%x", msgType);
209        Parcel data, reply;
210        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
211        data.writeInt32(msgType);
212        remote()->transact(TAKE_PICTURE, data, &reply);
213        status_t ret = reply.readInt32();
214        return ret;
215    }
216
217    // set preview/capture parameters - key/value pairs
218    status_t setParameters(const String8& params)
219    {
220        ALOGV("setParameters");
221        Parcel data, reply;
222        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
223        data.writeString8(params);
224        remote()->transact(SET_PARAMETERS, data, &reply);
225        return reply.readInt32();
226    }
227
228    // get preview/capture parameters - key/value pairs
229    String8 getParameters() const
230    {
231        ALOGV("getParameters");
232        Parcel data, reply;
233        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
234        remote()->transact(GET_PARAMETERS, data, &reply);
235        return reply.readString8();
236    }
237    virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
238    {
239        ALOGV("sendCommand");
240        Parcel data, reply;
241        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
242        data.writeInt32(cmd);
243        data.writeInt32(arg1);
244        data.writeInt32(arg2);
245        remote()->transact(SEND_COMMAND, data, &reply);
246        return reply.readInt32();
247    }
248    virtual status_t connect(const sp<ICameraClient>& cameraClient)
249    {
250        Parcel data, reply;
251        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
252        data.writeStrongBinder(cameraClient->asBinder());
253        remote()->transact(CONNECT, data, &reply);
254        return reply.readInt32();
255    }
256    virtual status_t lock()
257    {
258        Parcel data, reply;
259        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
260        remote()->transact(LOCK, data, &reply);
261        return reply.readInt32();
262    }
263    virtual status_t unlock()
264    {
265        Parcel data, reply;
266        data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
267        remote()->transact(UNLOCK, data, &reply);
268        return reply.readInt32();
269    }
270};
271
272IMPLEMENT_META_INTERFACE(Camera, "android.hardware.ICamera");
273
274// ----------------------------------------------------------------------
275
276status_t BnCamera::onTransact(
277    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
278{
279    switch(code) {
280        case DISCONNECT: {
281            ALOGV("DISCONNECT");
282            CHECK_INTERFACE(ICamera, data, reply);
283            disconnect();
284            return NO_ERROR;
285        } break;
286        case SET_PREVIEW_TEXTURE: {
287            ALOGV("SET_PREVIEW_TEXTURE");
288            CHECK_INTERFACE(ICamera, data, reply);
289            sp<IGraphicBufferProducer> st =
290                interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
291            reply->writeInt32(setPreviewTexture(st));
292            return NO_ERROR;
293        } break;
294        case SET_PREVIEW_CALLBACK_FLAG: {
295            ALOGV("SET_PREVIEW_CALLBACK_TYPE");
296            CHECK_INTERFACE(ICamera, data, reply);
297            int callback_flag = data.readInt32();
298            setPreviewCallbackFlag(callback_flag);
299            return NO_ERROR;
300        } break;
301        case SET_PREVIEW_CALLBACK_TARGET: {
302            ALOGV("SET_PREVIEW_CALLBACK_TARGET");
303            CHECK_INTERFACE(ICamera, data, reply);
304            sp<IGraphicBufferProducer> cp =
305                interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
306            reply->writeInt32(setPreviewCallbackTarget(cp));
307            return NO_ERROR;
308        }
309        case START_PREVIEW: {
310            ALOGV("START_PREVIEW");
311            CHECK_INTERFACE(ICamera, data, reply);
312            reply->writeInt32(startPreview());
313            return NO_ERROR;
314        } break;
315        case START_RECORDING: {
316            ALOGV("START_RECORDING");
317            CHECK_INTERFACE(ICamera, data, reply);
318            reply->writeInt32(startRecording());
319            return NO_ERROR;
320        } break;
321        case STOP_PREVIEW: {
322            ALOGV("STOP_PREVIEW");
323            CHECK_INTERFACE(ICamera, data, reply);
324            stopPreview();
325            return NO_ERROR;
326        } break;
327        case STOP_RECORDING: {
328            ALOGV("STOP_RECORDING");
329            CHECK_INTERFACE(ICamera, data, reply);
330            stopRecording();
331            return NO_ERROR;
332        } break;
333        case RELEASE_RECORDING_FRAME: {
334            ALOGV("RELEASE_RECORDING_FRAME");
335            CHECK_INTERFACE(ICamera, data, reply);
336            sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());
337            releaseRecordingFrame(mem);
338            return NO_ERROR;
339        } break;
340        case STORE_META_DATA_IN_BUFFERS: {
341            ALOGV("STORE_META_DATA_IN_BUFFERS");
342            CHECK_INTERFACE(ICamera, data, reply);
343            bool enabled = data.readInt32();
344            reply->writeInt32(storeMetaDataInBuffers(enabled));
345            return NO_ERROR;
346        } break;
347        case PREVIEW_ENABLED: {
348            ALOGV("PREVIEW_ENABLED");
349            CHECK_INTERFACE(ICamera, data, reply);
350            reply->writeInt32(previewEnabled());
351            return NO_ERROR;
352        } break;
353        case RECORDING_ENABLED: {
354            ALOGV("RECORDING_ENABLED");
355            CHECK_INTERFACE(ICamera, data, reply);
356            reply->writeInt32(recordingEnabled());
357            return NO_ERROR;
358        } break;
359        case AUTO_FOCUS: {
360            ALOGV("AUTO_FOCUS");
361            CHECK_INTERFACE(ICamera, data, reply);
362            reply->writeInt32(autoFocus());
363            return NO_ERROR;
364        } break;
365        case CANCEL_AUTO_FOCUS: {
366            ALOGV("CANCEL_AUTO_FOCUS");
367            CHECK_INTERFACE(ICamera, data, reply);
368            reply->writeInt32(cancelAutoFocus());
369            return NO_ERROR;
370        } break;
371        case TAKE_PICTURE: {
372            ALOGV("TAKE_PICTURE");
373            CHECK_INTERFACE(ICamera, data, reply);
374            int msgType = data.readInt32();
375            reply->writeInt32(takePicture(msgType));
376            return NO_ERROR;
377        } break;
378        case SET_PARAMETERS: {
379            ALOGV("SET_PARAMETERS");
380            CHECK_INTERFACE(ICamera, data, reply);
381            String8 params(data.readString8());
382            reply->writeInt32(setParameters(params));
383            return NO_ERROR;
384         } break;
385        case GET_PARAMETERS: {
386            ALOGV("GET_PARAMETERS");
387            CHECK_INTERFACE(ICamera, data, reply);
388             reply->writeString8(getParameters());
389            return NO_ERROR;
390         } break;
391        case SEND_COMMAND: {
392            ALOGV("SEND_COMMAND");
393            CHECK_INTERFACE(ICamera, data, reply);
394            int command = data.readInt32();
395            int arg1 = data.readInt32();
396            int arg2 = data.readInt32();
397            reply->writeInt32(sendCommand(command, arg1, arg2));
398            return NO_ERROR;
399         } break;
400        case CONNECT: {
401            CHECK_INTERFACE(ICamera, data, reply);
402            sp<ICameraClient> cameraClient = interface_cast<ICameraClient>(data.readStrongBinder());
403            reply->writeInt32(connect(cameraClient));
404            return NO_ERROR;
405        } break;
406        case LOCK: {
407            CHECK_INTERFACE(ICamera, data, reply);
408            reply->writeInt32(lock());
409            return NO_ERROR;
410        } break;
411        case UNLOCK: {
412            CHECK_INTERFACE(ICamera, data, reply);
413            reply->writeInt32(unlock());
414            return NO_ERROR;
415        } break;
416        default:
417            return BBinder::onTransact(code, data, reply, flags);
418    }
419}
420
421// ----------------------------------------------------------------------------
422
423}; // namespace android
424