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 <android/hardware/ICamera.h>
21 #include <android/hardware/ICameraClient.h>
22 #include <binder/Parcel.h>
23 #include <camera/CameraUtils.h>
24 #include <gui/Surface.h>
25 #include <gui/view/Surface.h>
26 #include <media/hardware/HardwareAPI.h>
27 #include <stdint.h>
28 #include <sys/types.h>
29 #include <utils/Log.h>
30
31 namespace android {
32 namespace hardware {
33
34 enum {
35 DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
36 SET_PREVIEW_TARGET,
37 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
38 SET_PREVIEW_TARGET_SURFACE,
39 #endif
40 SET_PREVIEW_CALLBACK_FLAG,
41 SET_PREVIEW_CALLBACK_TARGET,
42 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
43 SET_PREVIEW_CALLBACK_TARGET_SURFACE,
44 #endif
45 START_PREVIEW,
46 STOP_PREVIEW,
47 AUTO_FOCUS,
48 CANCEL_AUTO_FOCUS,
49 TAKE_PICTURE,
50 SET_PARAMETERS,
51 GET_PARAMETERS,
52 SEND_COMMAND,
53 CONNECT,
54 LOCK,
55 UNLOCK,
56 PREVIEW_ENABLED,
57 START_RECORDING,
58 STOP_RECORDING,
59 RECORDING_ENABLED,
60 RELEASE_RECORDING_FRAME,
61 SET_VIDEO_BUFFER_MODE,
62 SET_VIDEO_BUFFER_TARGET,
63 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
64 SET_VIDEO_BUFFER_TARGET_SURFACE,
65 #endif
66 RELEASE_RECORDING_FRAME_HANDLE,
67 RELEASE_RECORDING_FRAME_HANDLE_BATCH,
68 SET_AUDIO_RESTRICTION,
69 GET_GLOBAL_AUDIO_RESTRICTION,
70 };
71
72 class BpCamera: public BpInterface<ICamera>
73 {
74 public:
BpCamera(const sp<IBinder> & impl)75 explicit BpCamera(const sp<IBinder>& impl)
76 : BpInterface<ICamera>(impl)
77 {
78 }
79
80 // disconnect from camera service
disconnect()81 binder::Status disconnect()
82 {
83 ALOGV("disconnect");
84 Parcel data, reply;
85 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
86 remote()->transact(DISCONNECT, data, &reply);
87 reply.readExceptionCode();
88 return binder::Status::ok();
89 }
90
91 // pass the Surface to the camera service
setPreviewTarget(const sp<SurfaceType> & target)92 status_t setPreviewTarget(const sp<SurfaceType>& target) {
93 ALOGV("setPreviewTarget");
94 Parcel data, reply;
95 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
96 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
97 view::Surface viewSurfaceProducer = view::Surface::fromSurface(target);
98 data.writeParcelable(viewSurfaceProducer);
99 remote()->transact(SET_PREVIEW_TARGET_SURFACE, data, &reply);
100 #else
101 sp<IBinder> b(IInterface::asBinder(target));
102 data.writeStrongBinder(b);
103 remote()->transact(SET_PREVIEW_TARGET, data, &reply);
104 #endif
105 return reply.readInt32();
106 }
107
108 // set the preview callback flag to affect how the received frames from
109 // preview are handled. See Camera.h for details.
setPreviewCallbackFlag(int flag)110 void setPreviewCallbackFlag(int flag)
111 {
112 ALOGV("setPreviewCallbackFlag(%d)", flag);
113 Parcel data, reply;
114 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
115 data.writeInt32(flag);
116 remote()->transact(SET_PREVIEW_CALLBACK_FLAG, data, &reply);
117 }
118
setPreviewCallbackTarget(const sp<SurfaceType> & target)119 status_t setPreviewCallbackTarget(const sp<SurfaceType>& target) {
120 ALOGV("setPreviewCallbackTarget");
121 Parcel data, reply;
122 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
123 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
124 view::Surface viewCallbackProducer = view::Surface::fromSurface(target);
125 data.writeParcelable(viewCallbackProducer);
126 remote()->transact(SET_PREVIEW_CALLBACK_TARGET_SURFACE, data, &reply);
127 #else
128 sp<IBinder> b(IInterface::asBinder(target));
129 data.writeStrongBinder(b);
130 remote()->transact(SET_PREVIEW_CALLBACK_TARGET, data, &reply);
131 #endif
132 return reply.readInt32();
133 }
134
135 // start preview mode, must call setPreviewTarget first
startPreview()136 status_t startPreview()
137 {
138 ALOGV("startPreview");
139 Parcel data, reply;
140 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
141 remote()->transact(START_PREVIEW, data, &reply);
142 return reply.readInt32();
143 }
144
145 // start recording mode, must call setPreviewTarget first
startRecording()146 status_t startRecording()
147 {
148 ALOGV("startRecording");
149 Parcel data, reply;
150 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
151 remote()->transact(START_RECORDING, data, &reply);
152 return reply.readInt32();
153 }
154
155 // stop preview mode
stopPreview()156 void stopPreview()
157 {
158 ALOGV("stopPreview");
159 Parcel data, reply;
160 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
161 remote()->transact(STOP_PREVIEW, data, &reply);
162 }
163
164 // stop recording mode
stopRecording()165 void stopRecording()
166 {
167 ALOGV("stopRecording");
168 Parcel data, reply;
169 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
170 remote()->transact(STOP_RECORDING, data, &reply);
171 }
172
releaseRecordingFrame(const sp<IMemory> & mem)173 void releaseRecordingFrame(const sp<IMemory>& mem)
174 {
175 ALOGV("releaseRecordingFrame");
176 Parcel data, reply;
177 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
178 data.writeStrongBinder(IInterface::asBinder(mem));
179
180 remote()->transact(RELEASE_RECORDING_FRAME, data, &reply);
181 }
182
releaseRecordingFrameHandle(native_handle_t * handle)183 void releaseRecordingFrameHandle(native_handle_t *handle) {
184 ALOGV("releaseRecordingFrameHandle");
185 Parcel data, reply;
186 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
187 data.writeNativeHandle(handle);
188
189 remote()->transact(RELEASE_RECORDING_FRAME_HANDLE, data, &reply);
190
191 // Close the native handle because camera received a dup copy.
192 native_handle_close(handle);
193 native_handle_delete(handle);
194 }
195
releaseRecordingFrameHandleBatch(const std::vector<native_handle_t * > & handles)196 void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
197 ALOGV("releaseRecordingFrameHandleBatch");
198 Parcel data, reply;
199 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
200 uint32_t n = handles.size();
201 data.writeUint32(n);
202 for (auto& handle : handles) {
203 data.writeNativeHandle(handle);
204 }
205 remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);
206
207 // Close the native handle because camera received a dup copy.
208 for (auto& handle : handles) {
209 native_handle_close(handle);
210 native_handle_delete(handle);
211 }
212 }
213
setAudioRestriction(int32_t mode)214 status_t setAudioRestriction(int32_t mode) {
215 Parcel data, reply;
216 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
217 data.writeInt32(mode);
218 remote()->transact(SET_AUDIO_RESTRICTION, data, &reply);
219 return reply.readInt32();
220 }
221
getGlobalAudioRestriction()222 int32_t getGlobalAudioRestriction() {
223 Parcel data, reply;
224 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
225 remote()->transact(GET_GLOBAL_AUDIO_RESTRICTION, data, &reply);
226 return reply.readInt32();
227 }
228
setVideoBufferMode(int32_t videoBufferMode)229 status_t setVideoBufferMode(int32_t videoBufferMode)
230 {
231 ALOGV("setVideoBufferMode: %d", videoBufferMode);
232 Parcel data, reply;
233 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
234 data.writeInt32(videoBufferMode);
235 remote()->transact(SET_VIDEO_BUFFER_MODE, data, &reply);
236 return reply.readInt32();
237 }
238
239 // check preview state
previewEnabled()240 bool previewEnabled()
241 {
242 ALOGV("previewEnabled");
243 Parcel data, reply;
244 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
245 remote()->transact(PREVIEW_ENABLED, data, &reply);
246 return reply.readInt32();
247 }
248
249 // check recording state
recordingEnabled()250 bool recordingEnabled()
251 {
252 ALOGV("recordingEnabled");
253 Parcel data, reply;
254 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
255 remote()->transact(RECORDING_ENABLED, data, &reply);
256 return reply.readInt32();
257 }
258
259 // auto focus
autoFocus()260 status_t autoFocus()
261 {
262 ALOGV("autoFocus");
263 Parcel data, reply;
264 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
265 remote()->transact(AUTO_FOCUS, data, &reply);
266 status_t ret = reply.readInt32();
267 return ret;
268 }
269
270 // cancel focus
cancelAutoFocus()271 status_t cancelAutoFocus()
272 {
273 ALOGV("cancelAutoFocus");
274 Parcel data, reply;
275 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
276 remote()->transact(CANCEL_AUTO_FOCUS, data, &reply);
277 status_t ret = reply.readInt32();
278 return ret;
279 }
280
281 // take a picture - returns an IMemory (ref-counted mmap)
takePicture(int msgType)282 status_t takePicture(int msgType)
283 {
284 ALOGV("takePicture: 0x%x", msgType);
285 Parcel data, reply;
286 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
287 data.writeInt32(msgType);
288 remote()->transact(TAKE_PICTURE, data, &reply);
289 status_t ret = reply.readInt32();
290 return ret;
291 }
292
293 // set preview/capture parameters - key/value pairs
setParameters(const String8 & params)294 status_t setParameters(const String8& params)
295 {
296 ALOGV("setParameters");
297 Parcel data, reply;
298 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
299 data.writeString8(params);
300 remote()->transact(SET_PARAMETERS, data, &reply);
301 return reply.readInt32();
302 }
303
304 // get preview/capture parameters - key/value pairs
getParameters() const305 String8 getParameters() const
306 {
307 ALOGV("getParameters");
308 Parcel data, reply;
309 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
310 remote()->transact(GET_PARAMETERS, data, &reply);
311 return reply.readString8();
312 }
sendCommand(int32_t cmd,int32_t arg1,int32_t arg2)313 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
314 {
315 ALOGV("sendCommand");
316 Parcel data, reply;
317 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
318 data.writeInt32(cmd);
319 data.writeInt32(arg1);
320 data.writeInt32(arg2);
321 remote()->transact(SEND_COMMAND, data, &reply);
322 return reply.readInt32();
323 }
connect(const sp<ICameraClient> & cameraClient)324 virtual status_t connect(const sp<ICameraClient>& cameraClient)
325 {
326 Parcel data, reply;
327 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
328 data.writeStrongBinder(IInterface::asBinder(cameraClient));
329 remote()->transact(CONNECT, data, &reply);
330 return reply.readInt32();
331 }
lock()332 virtual status_t lock()
333 {
334 Parcel data, reply;
335 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
336 remote()->transact(LOCK, data, &reply);
337 return reply.readInt32();
338 }
unlock()339 virtual status_t unlock()
340 {
341 Parcel data, reply;
342 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
343 remote()->transact(UNLOCK, data, &reply);
344 return reply.readInt32();
345 }
346
setVideoTarget(const sp<SurfaceType> & target)347 status_t setVideoTarget(const sp<SurfaceType>& target) {
348 ALOGV("setVideoTarget");
349 Parcel data, reply;
350 data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
351 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
352 view::Surface viewSurfaceProducer = view::Surface::fromSurface(target);
353 data.writeParcelable(viewSurfaceProducer);
354 remote()->transact(SET_VIDEO_BUFFER_TARGET_SURFACE, data, &reply);
355 #else
356 sp<IBinder> b(IInterface::asBinder(target));
357 data.writeStrongBinder(b);
358 remote()->transact(SET_VIDEO_BUFFER_TARGET, data, &reply);
359 #endif
360 return reply.readInt32();
361 }
362 };
363
364 IMPLEMENT_META_INTERFACE(Camera, "android.hardware.ICamera");
365
366 // ----------------------------------------------------------------------
367
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)368 status_t BnCamera::onTransact(
369 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
370 {
371 switch(code) {
372 case DISCONNECT: {
373 ALOGV("DISCONNECT");
374 CHECK_INTERFACE(ICamera, data, reply);
375 disconnect();
376 reply->writeNoException();
377 return NO_ERROR;
378 } break;
379 case SET_PREVIEW_TARGET: {
380 ALOGV("SET_PREVIEW_TARGET");
381 CHECK_INTERFACE(ICamera, data, reply);
382 sp<IGraphicBufferProducer> st =
383 interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
384 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
385 sp<Surface> sp = new Surface(st);
386 reply->writeInt32(setPreviewTarget(sp));
387 #else
388 reply->writeInt32(setPreviewTarget(st));
389 #endif
390 return NO_ERROR;
391 } break;
392 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
393 case SET_PREVIEW_TARGET_SURFACE: {
394 ALOGV("SET_PREVIEW_TARGET_SURFACE");
395 CHECK_INTERFACE(ICamera, data, reply);
396 view::Surface viewSurface;
397 data.readParcelable(&viewSurface);
398 sp<Surface> st = viewSurface.toSurface();
399 reply->writeInt32(setPreviewTarget(st));
400 return NO_ERROR;
401 } break;
402 #endif
403 case SET_PREVIEW_CALLBACK_FLAG: {
404 ALOGV("SET_PREVIEW_CALLBACK_TYPE");
405 CHECK_INTERFACE(ICamera, data, reply);
406 int callback_flag = data.readInt32();
407 setPreviewCallbackFlag(callback_flag);
408 return NO_ERROR;
409 } break;
410 case SET_PREVIEW_CALLBACK_TARGET: {
411 ALOGV("SET_PREVIEW_CALLBACK_TARGET");
412 CHECK_INTERFACE(ICamera, data, reply);
413 sp<IGraphicBufferProducer> cp =
414 interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
415 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
416 sp<Surface> sp = new Surface(cp);
417 reply->writeInt32(setPreviewCallbackTarget(sp));
418 #else
419 reply->writeInt32(setPreviewCallbackTarget(cp));
420 #endif
421 return NO_ERROR;
422 }
423 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
424 case SET_PREVIEW_CALLBACK_TARGET_SURFACE: {
425 ALOGV("SET_PREVIEW_CALLBACK_TARGET_SURFACE");
426 CHECK_INTERFACE(ICamera, data, reply);
427 view::Surface viewSurface;
428 data.readParcelable(&viewSurface);
429 sp<Surface> cp = viewSurface.toSurface();
430 reply->writeInt32(setPreviewCallbackTarget(cp));
431 return NO_ERROR;
432 }
433 #endif
434 case START_PREVIEW: {
435 ALOGV("START_PREVIEW");
436 CHECK_INTERFACE(ICamera, data, reply);
437 reply->writeInt32(startPreview());
438 return NO_ERROR;
439 } break;
440 case START_RECORDING: {
441 ALOGV("START_RECORDING");
442 CHECK_INTERFACE(ICamera, data, reply);
443 reply->writeInt32(startRecording());
444 return NO_ERROR;
445 } break;
446 case STOP_PREVIEW: {
447 ALOGV("STOP_PREVIEW");
448 CHECK_INTERFACE(ICamera, data, reply);
449 stopPreview();
450 return NO_ERROR;
451 } break;
452 case STOP_RECORDING: {
453 ALOGV("STOP_RECORDING");
454 CHECK_INTERFACE(ICamera, data, reply);
455 stopRecording();
456 return NO_ERROR;
457 } break;
458 case RELEASE_RECORDING_FRAME: {
459 ALOGV("RELEASE_RECORDING_FRAME");
460 CHECK_INTERFACE(ICamera, data, reply);
461 sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());
462 releaseRecordingFrame(mem);
463 return NO_ERROR;
464 } break;
465 case RELEASE_RECORDING_FRAME_HANDLE: {
466 ALOGV("RELEASE_RECORDING_FRAME_HANDLE");
467 CHECK_INTERFACE(ICamera, data, reply);
468 // releaseRecordingFrameHandle will be responsble to close the native handle.
469 releaseRecordingFrameHandle(data.readNativeHandle());
470 return NO_ERROR;
471 } break;
472 case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {
473 ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");
474 CHECK_INTERFACE(ICamera, data, reply);
475 // releaseRecordingFrameHandle will be responsble to close the native handle.
476 uint32_t n = data.readUint32();
477 std::vector<native_handle_t*> handles;
478 handles.reserve(n);
479 for (uint32_t i = 0; i < n; i++) {
480 handles.push_back(data.readNativeHandle());
481 }
482 releaseRecordingFrameHandleBatch(handles);
483 return NO_ERROR;
484 } break;
485 case SET_VIDEO_BUFFER_MODE: {
486 ALOGV("SET_VIDEO_BUFFER_MODE");
487 CHECK_INTERFACE(ICamera, data, reply);
488 int32_t mode = data.readInt32();
489 reply->writeInt32(setVideoBufferMode(mode));
490 return NO_ERROR;
491 } break;
492 case PREVIEW_ENABLED: {
493 ALOGV("PREVIEW_ENABLED");
494 CHECK_INTERFACE(ICamera, data, reply);
495 reply->writeInt32(previewEnabled());
496 return NO_ERROR;
497 } break;
498 case RECORDING_ENABLED: {
499 ALOGV("RECORDING_ENABLED");
500 CHECK_INTERFACE(ICamera, data, reply);
501 reply->writeInt32(recordingEnabled());
502 return NO_ERROR;
503 } break;
504 case AUTO_FOCUS: {
505 ALOGV("AUTO_FOCUS");
506 CHECK_INTERFACE(ICamera, data, reply);
507 reply->writeInt32(autoFocus());
508 return NO_ERROR;
509 } break;
510 case CANCEL_AUTO_FOCUS: {
511 ALOGV("CANCEL_AUTO_FOCUS");
512 CHECK_INTERFACE(ICamera, data, reply);
513 reply->writeInt32(cancelAutoFocus());
514 return NO_ERROR;
515 } break;
516 case TAKE_PICTURE: {
517 ALOGV("TAKE_PICTURE");
518 CHECK_INTERFACE(ICamera, data, reply);
519 int msgType = data.readInt32();
520 reply->writeInt32(takePicture(msgType));
521 return NO_ERROR;
522 } break;
523 case SET_PARAMETERS: {
524 ALOGV("SET_PARAMETERS");
525 CHECK_INTERFACE(ICamera, data, reply);
526 String8 params(data.readString8());
527 reply->writeInt32(setParameters(params));
528 return NO_ERROR;
529 } break;
530 case GET_PARAMETERS: {
531 ALOGV("GET_PARAMETERS");
532 CHECK_INTERFACE(ICamera, data, reply);
533 reply->writeString8(getParameters());
534 return NO_ERROR;
535 } break;
536 case SEND_COMMAND: {
537 ALOGV("SEND_COMMAND");
538 CHECK_INTERFACE(ICamera, data, reply);
539 int command = data.readInt32();
540 int arg1 = data.readInt32();
541 int arg2 = data.readInt32();
542 reply->writeInt32(sendCommand(command, arg1, arg2));
543 return NO_ERROR;
544 } break;
545 case CONNECT: {
546 CHECK_INTERFACE(ICamera, data, reply);
547 sp<ICameraClient> cameraClient = interface_cast<ICameraClient>(data.readStrongBinder());
548 reply->writeInt32(connect(cameraClient));
549 return NO_ERROR;
550 } break;
551 case LOCK: {
552 CHECK_INTERFACE(ICamera, data, reply);
553 reply->writeInt32(lock());
554 return NO_ERROR;
555 } break;
556 case UNLOCK: {
557 CHECK_INTERFACE(ICamera, data, reply);
558 reply->writeInt32(unlock());
559 return NO_ERROR;
560 } break;
561 case SET_VIDEO_BUFFER_TARGET: {
562 ALOGV("SET_VIDEO_BUFFER_TARGET");
563 CHECK_INTERFACE(ICamera, data, reply);
564 sp<IGraphicBufferProducer> st =
565 interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
566 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
567 sp<Surface> sp = new Surface(st);
568 reply->writeInt32(setVideoTarget(sp));
569 #else
570 reply->writeInt32(setVideoTarget(st));
571 #endif
572 return NO_ERROR;
573 } break;
574 #if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
575 case SET_VIDEO_BUFFER_TARGET_SURFACE: {
576 ALOGV("SET_VIDEO_BUFFER_TARGET_SURFACE");
577 CHECK_INTERFACE(ICamera, data, reply);
578 view::Surface viewSurface;
579 data.readParcelable(&viewSurface);
580 sp<Surface> cp = viewSurface.toSurface();
581 reply->writeInt32(setVideoTarget(cp));
582 return NO_ERROR;
583 } break;
584 #endif
585 case SET_AUDIO_RESTRICTION: {
586 CHECK_INTERFACE(ICamera, data, reply);
587 int32_t mode = data.readInt32();
588 reply->writeInt32(setAudioRestriction(mode));
589 return NO_ERROR;
590 } break;
591 case GET_GLOBAL_AUDIO_RESTRICTION: {
592 CHECK_INTERFACE(ICamera, data, reply);
593 reply->writeInt32(getGlobalAudioRestriction());
594 return NO_ERROR;
595 } break;
596 default:
597 return BBinder::onTransact(code, data, reply, flags);
598 }
599 }
600
601 // ----------------------------------------------------------------------------
602
603 } // namespace hardware
604 } // namespace android
605