ICameraDeviceUser.cpp revision cb0652e5a850b2fcd919e977247e87239efaf70e 
1/*
2**
3** Copyright 2013, 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 "ICameraDeviceUser"
20#include <utils/Log.h>
21#include <stdint.h>
22#include <sys/types.h>
23#include <binder/Parcel.h>
24#include <camera/camera2/ICameraDeviceUser.h>
25#include <gui/IGraphicBufferProducer.h>
26#include <gui/Surface.h>
27#include <camera/CameraMetadata.h>
28#include <camera/camera2/CaptureRequest.h>
29
30namespace android {
31
32typedef Parcel::WritableBlob WritableBlob;
33typedef Parcel::ReadableBlob ReadableBlob;
34
35enum {
36    DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
37    SUBMIT_REQUEST,
38    SUBMIT_REQUEST_LIST,
39    CANCEL_REQUEST,
40    DELETE_STREAM,
41    CREATE_STREAM,
42    CREATE_DEFAULT_REQUEST,
43    GET_CAMERA_INFO,
44    WAIT_UNTIL_IDLE,
45    FLUSH
46};
47
48namespace {
49    // Read empty strings without printing a false error message.
50    String16 readMaybeEmptyString16(const Parcel& parcel) {
51        size_t len;
52        const char16_t* str = parcel.readString16Inplace(&len);
53        if (str != NULL) {
54            return String16(str, len);
55        } else {
56            return String16();
57        }
58    }
59};
60
61class BpCameraDeviceUser : public BpInterface<ICameraDeviceUser>
62{
63public:
64    BpCameraDeviceUser(const sp<IBinder>& impl)
65        : BpInterface<ICameraDeviceUser>(impl)
66    {
67    }
68
69    // disconnect from camera service
70    void disconnect()
71    {
72        ALOGV("disconnect");
73        Parcel data, reply;
74        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
75        remote()->transact(DISCONNECT, data, &reply);
76        reply.readExceptionCode();
77    }
78
79    virtual status_t submitRequest(sp<CaptureRequest> request, bool repeating,
80                              int64_t *lastFrameNumber)
81    {
82        Parcel data, reply;
83        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
84
85        // arg0 = CaptureRequest
86        if (request != 0) {
87            data.writeInt32(1);
88            request->writeToParcel(&data);
89        } else {
90            data.writeInt32(0);
91        }
92
93        // arg1 = streaming (bool)
94        data.writeInt32(repeating);
95
96        remote()->transact(SUBMIT_REQUEST, data, &reply);
97
98        reply.readExceptionCode();
99        status_t res = reply.readInt32();
100
101        status_t resFrameNumber = BAD_VALUE;
102        if (reply.readInt32() != 0) {
103            if (lastFrameNumber != NULL) {
104                resFrameNumber = reply.readInt64(lastFrameNumber);
105            }
106        }
107
108	if ((res != NO_ERROR) || (resFrameNumber != NO_ERROR)) {
109            res = FAILED_TRANSACTION;
110        }
111        return res;
112    }
113
114    virtual status_t submitRequestList(List<sp<CaptureRequest> > requestList, bool repeating,
115                                  int64_t *lastFrameNumber)
116    {
117        Parcel data, reply;
118        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
119
120        data.writeInt32(requestList.size());
121
122        for (List<sp<CaptureRequest> >::iterator it = requestList.begin();
123                it != requestList.end(); ++it) {
124            sp<CaptureRequest> request = *it;
125            if (request != 0) {
126                data.writeInt32(1);
127                if (request->writeToParcel(&data) != OK) {
128                    return BAD_VALUE;
129                }
130            } else {
131                data.writeInt32(0);
132            }
133        }
134
135        data.writeInt32(repeating);
136
137        remote()->transact(SUBMIT_REQUEST_LIST, data, &reply);
138
139        reply.readExceptionCode();
140        status_t res = reply.readInt32();
141
142        status_t resFrameNumber = BAD_VALUE;
143        if (reply.readInt32() != 0) {
144            if (lastFrameNumber != NULL) {
145                resFrameNumber = reply.readInt64(lastFrameNumber);
146            }
147        }
148        if ((res != NO_ERROR) || (resFrameNumber != NO_ERROR)) {
149            res = FAILED_TRANSACTION;
150        }
151        return res;
152    }
153
154    virtual status_t cancelRequest(int requestId, int64_t *lastFrameNumber)
155    {
156        Parcel data, reply;
157        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
158        data.writeInt32(requestId);
159
160        remote()->transact(CANCEL_REQUEST, data, &reply);
161
162        reply.readExceptionCode();
163        status_t res = reply.readInt32();
164
165        status_t resFrameNumber = BAD_VALUE;
166        if (reply.readInt32() != 0) {
167            if (lastFrameNumber != NULL) {
168                res = reply.readInt64(lastFrameNumber);
169            }
170        }
171        if ((res != NO_ERROR) || (resFrameNumber != NO_ERROR)) {
172            res = FAILED_TRANSACTION;
173        }
174        return res;
175    }
176
177    virtual status_t deleteStream(int streamId)
178    {
179        Parcel data, reply;
180        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
181        data.writeInt32(streamId);
182
183        remote()->transact(DELETE_STREAM, data, &reply);
184
185        reply.readExceptionCode();
186        return reply.readInt32();
187    }
188
189    virtual status_t createStream(int width, int height, int format,
190                          const sp<IGraphicBufferProducer>& bufferProducer)
191    {
192        Parcel data, reply;
193        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
194        data.writeInt32(width);
195        data.writeInt32(height);
196        data.writeInt32(format);
197
198        data.writeInt32(1); // marker that bufferProducer is not null
199        data.writeString16(String16("unknown_name")); // name of surface
200        sp<IBinder> b(bufferProducer->asBinder());
201        data.writeStrongBinder(b);
202
203        remote()->transact(CREATE_STREAM, data, &reply);
204
205        reply.readExceptionCode();
206        return reply.readInt32();
207    }
208
209    // Create a request object from a template.
210    virtual status_t createDefaultRequest(int templateId,
211                                          /*out*/
212                                          CameraMetadata* request)
213    {
214        Parcel data, reply;
215        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
216        data.writeInt32(templateId);
217        remote()->transact(CREATE_DEFAULT_REQUEST, data, &reply);
218
219        reply.readExceptionCode();
220        status_t result = reply.readInt32();
221
222        CameraMetadata out;
223        if (reply.readInt32() != 0) {
224            out.readFromParcel(&reply);
225        }
226
227        if (request != NULL) {
228            request->swap(out);
229        }
230        return result;
231    }
232
233
234    virtual status_t getCameraInfo(CameraMetadata* info)
235    {
236        Parcel data, reply;
237        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
238        remote()->transact(GET_CAMERA_INFO, data, &reply);
239
240        reply.readExceptionCode();
241        status_t result = reply.readInt32();
242
243        CameraMetadata out;
244        if (reply.readInt32() != 0) {
245            out.readFromParcel(&reply);
246        }
247
248        if (info != NULL) {
249            info->swap(out);
250        }
251
252        return result;
253    }
254
255    virtual status_t waitUntilIdle()
256    {
257        ALOGV("waitUntilIdle");
258        Parcel data, reply;
259        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
260        remote()->transact(WAIT_UNTIL_IDLE, data, &reply);
261        reply.readExceptionCode();
262        return reply.readInt32();
263    }
264
265    virtual status_t flush(int64_t *lastFrameNumber)
266    {
267        ALOGV("flush");
268        Parcel data, reply;
269        data.writeInterfaceToken(ICameraDeviceUser::getInterfaceDescriptor());
270        remote()->transact(FLUSH, data, &reply);
271        reply.readExceptionCode();
272        status_t res = reply.readInt32();
273
274        status_t resFrameNumber = BAD_VALUE;
275        if (reply.readInt32() != 0) {
276            if (lastFrameNumber != NULL) {
277                res = reply.readInt64(lastFrameNumber);
278            }
279        }
280        if ((res != NO_ERROR) || (resFrameNumber != NO_ERROR)) {
281            res = FAILED_TRANSACTION;
282        }
283        return res;
284    }
285
286private:
287
288
289};
290
291IMPLEMENT_META_INTERFACE(CameraDeviceUser,
292                         "android.hardware.camera2.ICameraDeviceUser");
293
294// ----------------------------------------------------------------------
295
296status_t BnCameraDeviceUser::onTransact(
297    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
298{
299    switch(code) {
300        case DISCONNECT: {
301            ALOGV("DISCONNECT");
302            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
303            disconnect();
304            reply->writeNoException();
305            return NO_ERROR;
306        } break;
307        case SUBMIT_REQUEST: {
308            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
309
310            // arg0 = request
311            sp<CaptureRequest> request;
312            if (data.readInt32() != 0) {
313                request = new CaptureRequest();
314                request->readFromParcel(const_cast<Parcel*>(&data));
315            }
316
317            // arg1 = streaming (bool)
318            bool repeating = data.readInt32();
319
320            // return code: requestId (int32)
321            reply->writeNoException();
322            int64_t lastFrameNumber = -1;
323            reply->writeInt32(submitRequest(request, repeating, &lastFrameNumber));
324            reply->writeInt32(1);
325            reply->writeInt64(lastFrameNumber);
326
327            return NO_ERROR;
328        } break;
329        case SUBMIT_REQUEST_LIST: {
330            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
331
332            List<sp<CaptureRequest> > requestList;
333            int requestListSize = data.readInt32();
334            for (int i = 0; i < requestListSize; i++) {
335                if (data.readInt32() != 0) {
336                    sp<CaptureRequest> request = new CaptureRequest();
337                    if (request->readFromParcel(const_cast<Parcel*>(&data)) != OK) {
338                        return BAD_VALUE;
339                    }
340                    requestList.push_back(request);
341                } else {
342                    sp<CaptureRequest> request = 0;
343                    requestList.push_back(request);
344                    ALOGE("A request is missing. Sending in null request.");
345                }
346            }
347
348            bool repeating = data.readInt32();
349
350            reply->writeNoException();
351            int64_t lastFrameNumber = -1;
352            reply->writeInt32(submitRequestList(requestList, repeating, &lastFrameNumber));
353            reply->writeInt32(1);
354            reply->writeInt64(lastFrameNumber);
355
356            return NO_ERROR;
357        } break;
358        case CANCEL_REQUEST: {
359            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
360            int requestId = data.readInt32();
361            reply->writeNoException();
362            int64_t lastFrameNumber = -1;
363            reply->writeInt32(cancelRequest(requestId, &lastFrameNumber));
364            reply->writeInt32(1);
365            reply->writeInt64(lastFrameNumber);
366            return NO_ERROR;
367        } break;
368        case DELETE_STREAM: {
369            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
370            int streamId = data.readInt32();
371            reply->writeNoException();
372            reply->writeInt32(deleteStream(streamId));
373            return NO_ERROR;
374        } break;
375        case CREATE_STREAM: {
376            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
377            int width, height, format;
378
379            width = data.readInt32();
380            ALOGV("%s: CREATE_STREAM: width = %d", __FUNCTION__, width);
381            height = data.readInt32();
382            ALOGV("%s: CREATE_STREAM: height = %d", __FUNCTION__, height);
383            format = data.readInt32();
384            ALOGV("%s: CREATE_STREAM: format = %d", __FUNCTION__, format);
385
386            sp<IGraphicBufferProducer> bp;
387            if (data.readInt32() != 0) {
388                String16 name = readMaybeEmptyString16(data);
389                bp = interface_cast<IGraphicBufferProducer>(
390                        data.readStrongBinder());
391
392                ALOGV("%s: CREATE_STREAM: bp = %p, name = %s", __FUNCTION__,
393                      bp.get(), String8(name).string());
394            } else {
395                ALOGV("%s: CREATE_STREAM: bp = unset, name = unset",
396                      __FUNCTION__);
397            }
398
399            status_t ret;
400            ret = createStream(width, height, format, bp);
401
402            reply->writeNoException();
403            ALOGV("%s: CREATE_STREAM: write noException", __FUNCTION__);
404            reply->writeInt32(ret);
405            ALOGV("%s: CREATE_STREAM: write ret = %d", __FUNCTION__, ret);
406
407            return NO_ERROR;
408        } break;
409
410        case CREATE_DEFAULT_REQUEST: {
411            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
412
413            int templateId = data.readInt32();
414
415            CameraMetadata request;
416            status_t ret;
417            ret = createDefaultRequest(templateId, &request);
418
419            reply->writeNoException();
420            reply->writeInt32(ret);
421
422            // out-variables are after exception and return value
423            reply->writeInt32(1); // to mark presence of metadata object
424            request.writeToParcel(const_cast<Parcel*>(reply));
425
426            return NO_ERROR;
427        } break;
428        case GET_CAMERA_INFO: {
429            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
430
431            CameraMetadata info;
432            status_t ret;
433            ret = getCameraInfo(&info);
434
435            reply->writeNoException();
436            reply->writeInt32(ret);
437
438            // out-variables are after exception and return value
439            reply->writeInt32(1); // to mark presence of metadata object
440            info.writeToParcel(reply);
441
442            return NO_ERROR;
443        } break;
444        case WAIT_UNTIL_IDLE: {
445            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
446            reply->writeNoException();
447            reply->writeInt32(waitUntilIdle());
448            return NO_ERROR;
449        } break;
450        case FLUSH: {
451            CHECK_INTERFACE(ICameraDeviceUser, data, reply);
452            reply->writeNoException();
453            int64_t lastFrameNumber = -1;
454            reply->writeInt32(flush(&lastFrameNumber));
455            reply->writeInt32(1);
456            reply->writeInt64(lastFrameNumber);
457            return NO_ERROR;
458        }
459        default:
460            return BBinder::onTransact(code, data, reply, flags);
461    }
462}
463
464// ----------------------------------------------------------------------------
465
466}; // namespace android
467