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 "IMediaRecorder"
20
21 #include <inttypes.h>
22 #include <unistd.h>
23
24 #include <utils/Log.h>
25 #include <binder/Parcel.h>
26 #include <camera/android/hardware/ICamera.h>
27 #include <camera/ICameraRecordingProxy.h>
28 #include <media/IMediaRecorderClient.h>
29 #include <media/IMediaRecorder.h>
30 #include <gui/Surface.h>
31 #include <gui/IGraphicBufferProducer.h>
32 #include <media/stagefright/PersistentSurface.h>
33
34 namespace android {
35
36 enum {
37 RELEASE = IBinder::FIRST_CALL_TRANSACTION,
38 INIT,
39 CLOSE,
40 SET_INPUT_SURFACE,
41 QUERY_SURFACE_MEDIASOURCE,
42 RESET,
43 STOP,
44 START,
45 PREPARE,
46 GET_MAX_AMPLITUDE,
47 SET_VIDEO_SOURCE,
48 SET_AUDIO_SOURCE,
49 SET_OUTPUT_FORMAT,
50 SET_VIDEO_ENCODER,
51 SET_AUDIO_ENCODER,
52 SET_OUTPUT_FILE_FD,
53 SET_NEXT_OUTPUT_FILE_FD,
54 SET_VIDEO_SIZE,
55 SET_VIDEO_FRAMERATE,
56 SET_PARAMETERS,
57 SET_PREVIEW_SURFACE,
58 SET_CAMERA,
59 SET_LISTENER,
60 SET_CLIENT_NAME,
61 PAUSE,
62 RESUME,
63 GET_METRICS,
64 SET_INPUT_DEVICE,
65 GET_ROUTED_DEVICE_ID,
66 ENABLE_AUDIO_DEVICE_CALLBACK,
67 GET_ACTIVE_MICROPHONES,
68 GET_PORT_ID,
69 GET_RTP_DATA_USAGE,
70 SET_PREFERRED_MICROPHONE_DIRECTION,
71 SET_PREFERRED_MICROPHONE_FIELD_DIMENSION,
72 SET_PRIVACY_SENSITIVE,
73 GET_PRIVACY_SENSITIVE
74 };
75
76 class BpMediaRecorder: public BpInterface<IMediaRecorder>
77 {
78 public:
BpMediaRecorder(const sp<IBinder> & impl)79 explicit BpMediaRecorder(const sp<IBinder>& impl)
80 : BpInterface<IMediaRecorder>(impl)
81 {
82 }
83
setCamera(const sp<hardware::ICamera> & camera,const sp<ICameraRecordingProxy> & proxy)84 status_t setCamera(const sp<hardware::ICamera>& camera, const sp<ICameraRecordingProxy>& proxy)
85 {
86 ALOGV("setCamera(%p,%p)", camera.get(), proxy.get());
87 Parcel data, reply;
88 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
89 data.writeStrongBinder(IInterface::asBinder(camera));
90 data.writeStrongBinder(IInterface::asBinder(proxy));
91 remote()->transact(SET_CAMERA, data, &reply);
92 return reply.readInt32();
93 }
94
setInputSurface(const sp<PersistentSurface> & surface)95 status_t setInputSurface(const sp<PersistentSurface>& surface)
96 {
97 ALOGV("setInputSurface(%p)", surface.get());
98 Parcel data, reply;
99 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
100 surface->writeToParcel(&data);
101 remote()->transact(SET_INPUT_SURFACE, data, &reply);
102 return reply.readInt32();
103 }
104
querySurfaceMediaSource()105 sp<IGraphicBufferProducer> querySurfaceMediaSource()
106 {
107 ALOGV("Query SurfaceMediaSource");
108 Parcel data, reply;
109 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
110 remote()->transact(QUERY_SURFACE_MEDIASOURCE, data, &reply);
111 int returnedNull = reply.readInt32();
112 if (returnedNull) {
113 return NULL;
114 }
115 return interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
116 }
117
setPreviewSurface(const sp<IGraphicBufferProducer> & surface)118 status_t setPreviewSurface(const sp<IGraphicBufferProducer>& surface)
119 {
120 ALOGV("setPreviewSurface(%p)", surface.get());
121 Parcel data, reply;
122 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
123 data.writeStrongBinder(IInterface::asBinder(surface));
124 remote()->transact(SET_PREVIEW_SURFACE, data, &reply);
125 return reply.readInt32();
126 }
127
init()128 status_t init()
129 {
130 ALOGV("init");
131 Parcel data, reply;
132 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
133 remote()->transact(INIT, data, &reply);
134 return reply.readInt32();
135 }
136
setVideoSource(int vs)137 status_t setVideoSource(int vs)
138 {
139 ALOGV("setVideoSource(%d)", vs);
140 Parcel data, reply;
141 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
142 data.writeInt32(vs);
143 remote()->transact(SET_VIDEO_SOURCE, data, &reply);
144 return reply.readInt32();
145 }
146
setAudioSource(int as)147 status_t setAudioSource(int as)
148 {
149 ALOGV("setAudioSource(%d)", as);
150 Parcel data, reply;
151 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
152 data.writeInt32(as);
153 remote()->transact(SET_AUDIO_SOURCE, data, &reply);
154 return reply.readInt32();
155 }
156
setPrivacySensitive(bool privacySensitive)157 status_t setPrivacySensitive(bool privacySensitive)
158 {
159 ALOGV("%s(%s)", __func__, privacySensitive ? "true" : "false");
160 Parcel data, reply;
161 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
162 data.writeInt32(privacySensitive ? 1 : 0);
163 status_t status = remote()->transact(SET_PRIVACY_SENSITIVE, data, &reply);
164 if (status != NO_ERROR) {
165 return status;
166 }
167 return reply.readInt32();
168 }
169
isPrivacySensitive(bool * privacySensitive) const170 status_t isPrivacySensitive(bool *privacySensitive) const
171 {
172 Parcel data, reply;
173 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
174 *privacySensitive = false;
175 status_t status = remote()->transact(GET_PRIVACY_SENSITIVE, data, &reply);
176 if (status != NO_ERROR) {
177 return status;
178 }
179 status = reply.readInt32();
180 if (status == NO_ERROR) {
181 *privacySensitive = reply.readInt32() == 1;
182 }
183 ALOGV("%s status %d enabled: %s", __func__, status, *privacySensitive ? "true" : "false");
184 return status;
185 }
186
setOutputFormat(int of)187 status_t setOutputFormat(int of)
188 {
189 ALOGV("setOutputFormat(%d)", of);
190 Parcel data, reply;
191 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
192 data.writeInt32(of);
193 remote()->transact(SET_OUTPUT_FORMAT, data, &reply);
194 return reply.readInt32();
195 }
196
setVideoEncoder(int ve)197 status_t setVideoEncoder(int ve)
198 {
199 ALOGV("setVideoEncoder(%d)", ve);
200 Parcel data, reply;
201 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
202 data.writeInt32(ve);
203 remote()->transact(SET_VIDEO_ENCODER, data, &reply);
204 return reply.readInt32();
205 }
206
setAudioEncoder(int ae)207 status_t setAudioEncoder(int ae)
208 {
209 ALOGV("setAudioEncoder(%d)", ae);
210 Parcel data, reply;
211 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
212 data.writeInt32(ae);
213 remote()->transact(SET_AUDIO_ENCODER, data, &reply);
214 return reply.readInt32();
215 }
216
setOutputFile(int fd)217 status_t setOutputFile(int fd) {
218 ALOGV("setOutputFile(%d)", fd);
219 Parcel data, reply;
220 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
221 data.writeFileDescriptor(fd);
222 remote()->transact(SET_OUTPUT_FILE_FD, data, &reply);
223 return reply.readInt32();
224 }
225
setNextOutputFile(int fd)226 status_t setNextOutputFile(int fd) {
227 ALOGV("setNextOutputFile(%d)", fd);
228 Parcel data, reply;
229 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
230 data.writeFileDescriptor(fd);
231 remote()->transact(SET_NEXT_OUTPUT_FILE_FD, data, &reply);
232 return reply.readInt32();
233 }
234
setVideoSize(int width,int height)235 status_t setVideoSize(int width, int height)
236 {
237 ALOGV("setVideoSize(%dx%d)", width, height);
238 Parcel data, reply;
239 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
240 data.writeInt32(width);
241 data.writeInt32(height);
242 remote()->transact(SET_VIDEO_SIZE, data, &reply);
243 return reply.readInt32();
244 }
245
setVideoFrameRate(int frames_per_second)246 status_t setVideoFrameRate(int frames_per_second)
247 {
248 ALOGV("setVideoFrameRate(%d)", frames_per_second);
249 Parcel data, reply;
250 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
251 data.writeInt32(frames_per_second);
252 remote()->transact(SET_VIDEO_FRAMERATE, data, &reply);
253 return reply.readInt32();
254 }
255
setParameters(const String8 & params)256 status_t setParameters(const String8& params)
257 {
258 ALOGV("setParameter(%s)", params.string());
259 Parcel data, reply;
260 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
261 data.writeString8(params);
262 remote()->transact(SET_PARAMETERS, data, &reply);
263 return reply.readInt32();
264 }
265
setListener(const sp<IMediaRecorderClient> & listener)266 status_t setListener(const sp<IMediaRecorderClient>& listener)
267 {
268 ALOGV("setListener(%p)", listener.get());
269 Parcel data, reply;
270 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
271 data.writeStrongBinder(IInterface::asBinder(listener));
272 remote()->transact(SET_LISTENER, data, &reply);
273 return reply.readInt32();
274 }
275
setClientName(const String16 & clientName)276 status_t setClientName(const String16& clientName)
277 {
278 ALOGV("setClientName(%s)", String8(clientName).string());
279 Parcel data, reply;
280 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
281 data.writeString16(clientName);
282 remote()->transact(SET_CLIENT_NAME, data, &reply);
283 return reply.readInt32();
284 }
285
prepare()286 status_t prepare()
287 {
288 ALOGV("prepare");
289 Parcel data, reply;
290 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
291 remote()->transact(PREPARE, data, &reply);
292 return reply.readInt32();
293 }
294
getMaxAmplitude(int * max)295 status_t getMaxAmplitude(int* max)
296 {
297 ALOGV("getMaxAmplitude");
298 Parcel data, reply;
299 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
300 remote()->transact(GET_MAX_AMPLITUDE, data, &reply);
301 *max = reply.readInt32();
302 return reply.readInt32();
303 }
304
getMetrics(Parcel * reply)305 status_t getMetrics(Parcel* reply)
306 {
307 ALOGV("getMetrics");
308 Parcel data;
309 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
310 status_t ret = remote()->transact(GET_METRICS, data, reply);
311 if (ret == NO_ERROR) {
312 return OK;
313 }
314 return UNKNOWN_ERROR;
315 }
316
start()317 status_t start()
318 {
319 ALOGV("start");
320 Parcel data, reply;
321 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
322 remote()->transact(START, data, &reply);
323 return reply.readInt32();
324 }
325
stop()326 status_t stop()
327 {
328 ALOGV("stop");
329 Parcel data, reply;
330 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
331 remote()->transact(STOP, data, &reply);
332 return reply.readInt32();
333 }
334
reset()335 status_t reset()
336 {
337 ALOGV("reset");
338 Parcel data, reply;
339 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
340 remote()->transact(RESET, data, &reply);
341 return reply.readInt32();
342 }
343
pause()344 status_t pause()
345 {
346 ALOGV("pause");
347 Parcel data, reply;
348 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
349 remote()->transact(PAUSE, data, &reply);
350 return reply.readInt32();
351 }
352
resume()353 status_t resume()
354 {
355 ALOGV("resume");
356 Parcel data, reply;
357 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
358 remote()->transact(RESUME, data, &reply);
359 return reply.readInt32();
360 }
361
close()362 status_t close()
363 {
364 ALOGV("close");
365 Parcel data, reply;
366 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
367 remote()->transact(CLOSE, data, &reply);
368 return reply.readInt32();
369 }
370
release()371 status_t release()
372 {
373 ALOGV("release");
374 Parcel data, reply;
375 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
376 remote()->transact(RELEASE, data, &reply);
377 return reply.readInt32();
378 }
379
setInputDevice(audio_port_handle_t deviceId)380 status_t setInputDevice(audio_port_handle_t deviceId)
381 {
382 ALOGV("setInputDevice");
383 Parcel data, reply;
384 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
385 data.writeInt32(deviceId);
386
387 status_t status = remote()->transact(SET_INPUT_DEVICE, data, &reply);
388 if (status != OK) {
389 ALOGE("setInputDevice binder call failed: %d", status);
390 return status;
391 }
392 return reply.readInt32();;
393 }
394
getRoutedDeviceId(audio_port_handle_t * deviceId)395 audio_port_handle_t getRoutedDeviceId(audio_port_handle_t *deviceId)
396 {
397 ALOGV("getRoutedDeviceId");
398 Parcel data, reply;
399 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
400
401 status_t status = remote()->transact(GET_ROUTED_DEVICE_ID, data, &reply);
402 if (status != OK) {
403 ALOGE("getRoutedDeviceid binder call failed: %d", status);
404 *deviceId = AUDIO_PORT_HANDLE_NONE;
405 return status;
406 }
407
408 status = reply.readInt32();
409 if (status != NO_ERROR) {
410 *deviceId = AUDIO_PORT_HANDLE_NONE;
411 } else {
412 *deviceId = reply.readInt32();
413 }
414 return status;
415 }
416
enableAudioDeviceCallback(bool enabled)417 status_t enableAudioDeviceCallback(bool enabled)
418 {
419 ALOGV("enableAudioDeviceCallback");
420 Parcel data, reply;
421 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
422 data.writeBool(enabled);
423 status_t status = remote()->transact(ENABLE_AUDIO_DEVICE_CALLBACK, data, &reply);
424 if (status != OK) {
425 ALOGE("enableAudioDeviceCallback binder call failed: %d, %d", enabled, status);
426 return status;
427 }
428 return reply.readInt32();
429 }
430
getActiveMicrophones(std::vector<media::MicrophoneInfo> * activeMicrophones)431 status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones)
432 {
433 ALOGV("getActiveMicrophones");
434 Parcel data, reply;
435 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
436 status_t status = remote()->transact(GET_ACTIVE_MICROPHONES, data, &reply);
437 if (status != OK
438 || (status = (status_t)reply.readInt32()) != NO_ERROR) {
439 return status;
440 }
441 status = reply.readParcelableVector(activeMicrophones);
442 return status;
443 }
444
setPreferredMicrophoneDirection(audio_microphone_direction_t direction)445 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
446 ALOGV("setPreferredMicrophoneDirection(%d)", direction);
447 Parcel data, reply;
448 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
449 data.writeInt32(direction);
450 status_t status = remote()->transact(SET_PREFERRED_MICROPHONE_DIRECTION, data, &reply);
451 return status == NO_ERROR ? (status_t)reply.readInt32() : status;
452 }
453
setPreferredMicrophoneFieldDimension(float zoom)454 status_t setPreferredMicrophoneFieldDimension(float zoom) {
455 ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
456 Parcel data, reply;
457 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
458 data.writeFloat(zoom);
459 status_t status = remote()->transact(SET_PREFERRED_MICROPHONE_FIELD_DIMENSION, data, &reply);
460 return status == NO_ERROR ? (status_t)reply.readInt32() : status;
461 }
462
getPortId(audio_port_handle_t * portId)463 status_t getPortId(audio_port_handle_t *portId)
464 {
465 ALOGV("getPortId");
466 if (portId == nullptr) {
467 return BAD_VALUE;
468 }
469 Parcel data, reply;
470 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
471 status_t status = remote()->transact(GET_PORT_ID, data, &reply);
472 if (status != OK
473 || (status = (status_t)reply.readInt32()) != NO_ERROR) {
474 *portId = AUDIO_PORT_HANDLE_NONE;
475 return status;
476 }
477 *portId = (audio_port_handle_t)reply.readInt32();
478 return NO_ERROR;
479 }
480
getRtpDataUsage(uint64_t * bytes)481 status_t getRtpDataUsage(uint64_t *bytes)
482 {
483 ALOGV("getRtpDataUsage");
484 if (bytes == nullptr) {
485 return BAD_VALUE;
486 }
487 Parcel data, reply;
488 data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
489 status_t status = remote()->transact(GET_RTP_DATA_USAGE, data, &reply);
490 if (status != OK
491 || (status = (status_t)reply.readInt32()) != NO_ERROR) {
492 *bytes = 0;
493 return status;
494 }
495 return reply.readUint64(bytes);
496 }
497 };
498
499 IMPLEMENT_META_INTERFACE(MediaRecorder, "android.media.IMediaRecorder");
500
501 // ----------------------------------------------------------------------
502
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)503 status_t BnMediaRecorder::onTransact(
504 uint32_t code, const Parcel& data, Parcel* reply,
505 uint32_t flags)
506 {
507 switch (code) {
508 case RELEASE: {
509 ALOGV("RELEASE");
510 CHECK_INTERFACE(IMediaRecorder, data, reply);
511 reply->writeInt32(release());
512 return NO_ERROR;
513 } break;
514 case INIT: {
515 ALOGV("INIT");
516 CHECK_INTERFACE(IMediaRecorder, data, reply);
517 reply->writeInt32(init());
518 return NO_ERROR;
519 } break;
520 case CLOSE: {
521 ALOGV("CLOSE");
522 CHECK_INTERFACE(IMediaRecorder, data, reply);
523 reply->writeInt32(close());
524 return NO_ERROR;
525 } break;
526 case RESET: {
527 ALOGV("RESET");
528 CHECK_INTERFACE(IMediaRecorder, data, reply);
529 reply->writeInt32(reset());
530 return NO_ERROR;
531 } break;
532 case STOP: {
533 ALOGV("STOP");
534 CHECK_INTERFACE(IMediaRecorder, data, reply);
535 reply->writeInt32(stop());
536 return NO_ERROR;
537 } break;
538 case START: {
539 ALOGV("START");
540 CHECK_INTERFACE(IMediaRecorder, data, reply);
541 reply->writeInt32(start());
542 return NO_ERROR;
543 } break;
544 case PAUSE: {
545 ALOGV("PAUSE");
546 CHECK_INTERFACE(IMediaRecorder, data, reply);
547 reply->writeInt32(pause());
548 return NO_ERROR;
549 } break;
550 case RESUME: {
551 ALOGV("RESUME");
552 CHECK_INTERFACE(IMediaRecorder, data, reply);
553 reply->writeInt32(resume());
554 return NO_ERROR;
555 } break;
556 case PREPARE: {
557 ALOGV("PREPARE");
558 CHECK_INTERFACE(IMediaRecorder, data, reply);
559 reply->writeInt32(prepare());
560 return NO_ERROR;
561 } break;
562 case GET_MAX_AMPLITUDE: {
563 ALOGV("GET_MAX_AMPLITUDE");
564 CHECK_INTERFACE(IMediaRecorder, data, reply);
565 int max = 0;
566 status_t ret = getMaxAmplitude(&max);
567 reply->writeInt32(max);
568 reply->writeInt32(ret);
569 return NO_ERROR;
570 } break;
571 case GET_METRICS: {
572 ALOGV("GET_METRICS");
573 status_t ret = getMetrics(reply);
574 return ret;
575 } break;
576 case SET_VIDEO_SOURCE: {
577 ALOGV("SET_VIDEO_SOURCE");
578 CHECK_INTERFACE(IMediaRecorder, data, reply);
579 int vs = data.readInt32();
580 reply->writeInt32(setVideoSource(vs));
581 return NO_ERROR;
582 } break;
583 case SET_AUDIO_SOURCE: {
584 ALOGV("SET_AUDIO_SOURCE");
585 CHECK_INTERFACE(IMediaRecorder, data, reply);
586 int as = data.readInt32();
587 reply->writeInt32(setAudioSource(as));
588 return NO_ERROR;
589 } break;
590 case SET_PRIVACY_SENSITIVE: {
591 ALOGV("SET_PRIVACY_SENSITIVE");
592 CHECK_INTERFACE(IMediaRecorder, data, reply);
593 bool privacySensitive = data.readInt32() == 1;
594 reply->writeInt32(setPrivacySensitive(privacySensitive));
595 return NO_ERROR;
596 } break;
597 case GET_PRIVACY_SENSITIVE: {
598 ALOGV("GET_PRIVACY_SENSITIVE");
599 CHECK_INTERFACE(IMediaRecorder, data, reply);
600 bool privacySensitive = false;
601 status_t status = isPrivacySensitive(&privacySensitive);
602 reply->writeInt32(status);
603 if (status == NO_ERROR) {
604 reply->writeInt32(privacySensitive ? 1 : 0);
605 }
606 return NO_ERROR;
607 } break;
608 case SET_OUTPUT_FORMAT: {
609 ALOGV("SET_OUTPUT_FORMAT");
610 CHECK_INTERFACE(IMediaRecorder, data, reply);
611 int of = data.readInt32();
612 reply->writeInt32(setOutputFormat(of));
613 return NO_ERROR;
614 } break;
615 case SET_VIDEO_ENCODER: {
616 ALOGV("SET_VIDEO_ENCODER");
617 CHECK_INTERFACE(IMediaRecorder, data, reply);
618 int ve = data.readInt32();
619 reply->writeInt32(setVideoEncoder(ve));
620 return NO_ERROR;
621 } break;
622 case SET_AUDIO_ENCODER: {
623 ALOGV("SET_AUDIO_ENCODER");
624 CHECK_INTERFACE(IMediaRecorder, data, reply);
625 int ae = data.readInt32();
626 reply->writeInt32(setAudioEncoder(ae));
627 return NO_ERROR;
628
629 } break;
630 case SET_OUTPUT_FILE_FD: {
631 ALOGV("SET_OUTPUT_FILE_FD");
632 CHECK_INTERFACE(IMediaRecorder, data, reply);
633 int fd = dup(data.readFileDescriptor());
634 reply->writeInt32(setOutputFile(fd));
635 ::close(fd);
636 return NO_ERROR;
637 } break;
638 case SET_NEXT_OUTPUT_FILE_FD: {
639 ALOGV("SET_NEXT_OUTPUT_FILE_FD");
640 CHECK_INTERFACE(IMediaRecorder, data, reply);
641 int fd = dup(data.readFileDescriptor());
642 reply->writeInt32(setNextOutputFile(fd));
643 ::close(fd);
644 return NO_ERROR;
645 } break;
646 case SET_VIDEO_SIZE: {
647 ALOGV("SET_VIDEO_SIZE");
648 CHECK_INTERFACE(IMediaRecorder, data, reply);
649 int width = data.readInt32();
650 int height = data.readInt32();
651 reply->writeInt32(setVideoSize(width, height));
652 return NO_ERROR;
653 } break;
654 case SET_VIDEO_FRAMERATE: {
655 ALOGV("SET_VIDEO_FRAMERATE");
656 CHECK_INTERFACE(IMediaRecorder, data, reply);
657 int frames_per_second = data.readInt32();
658 reply->writeInt32(setVideoFrameRate(frames_per_second));
659 return NO_ERROR;
660 } break;
661 case SET_PARAMETERS: {
662 ALOGV("SET_PARAMETER");
663 CHECK_INTERFACE(IMediaRecorder, data, reply);
664 reply->writeInt32(setParameters(data.readString8()));
665 return NO_ERROR;
666 } break;
667 case SET_LISTENER: {
668 ALOGV("SET_LISTENER");
669 CHECK_INTERFACE(IMediaRecorder, data, reply);
670 sp<IMediaRecorderClient> listener =
671 interface_cast<IMediaRecorderClient>(data.readStrongBinder());
672 reply->writeInt32(setListener(listener));
673 return NO_ERROR;
674 } break;
675 case SET_CLIENT_NAME: {
676 ALOGV("SET_CLIENT_NAME");
677 CHECK_INTERFACE(IMediaRecorder, data, reply);
678 reply->writeInt32(setClientName(data.readString16()));
679 return NO_ERROR;
680 }
681 case SET_PREVIEW_SURFACE: {
682 ALOGV("SET_PREVIEW_SURFACE");
683 CHECK_INTERFACE(IMediaRecorder, data, reply);
684 sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(
685 data.readStrongBinder());
686 reply->writeInt32(setPreviewSurface(surface));
687 return NO_ERROR;
688 } break;
689 case SET_CAMERA: {
690 ALOGV("SET_CAMERA");
691 CHECK_INTERFACE(IMediaRecorder, data, reply);
692 sp<hardware::ICamera> camera =
693 interface_cast<hardware::ICamera>(data.readStrongBinder());
694 sp<ICameraRecordingProxy> proxy =
695 interface_cast<ICameraRecordingProxy>(data.readStrongBinder());
696 reply->writeInt32(setCamera(camera, proxy));
697 return NO_ERROR;
698 } break;
699 case SET_INPUT_SURFACE: {
700 ALOGV("SET_INPUT_SURFACE");
701 CHECK_INTERFACE(IMediaRecorder, data, reply);
702 sp<PersistentSurface> surface = new PersistentSurface();
703 surface->readFromParcel(&data);
704 reply->writeInt32(setInputSurface(surface));
705 return NO_ERROR;
706 } break;
707 case QUERY_SURFACE_MEDIASOURCE: {
708 ALOGV("QUERY_SURFACE_MEDIASOURCE");
709 CHECK_INTERFACE(IMediaRecorder, data, reply);
710 // call the mediaserver side to create
711 // a surfacemediasource
712 sp<IGraphicBufferProducer> surfaceMediaSource = querySurfaceMediaSource();
713 // The mediaserver might have failed to create a source
714 int returnedNull= (surfaceMediaSource == NULL) ? 1 : 0 ;
715 reply->writeInt32(returnedNull);
716 if (!returnedNull) {
717 reply->writeStrongBinder(IInterface::asBinder(surfaceMediaSource));
718 }
719 return NO_ERROR;
720 } break;
721 case SET_INPUT_DEVICE: {
722 ALOGV("SET_INPUT_DEVICE");
723 CHECK_INTERFACE(IMediaRecorder, data, reply);
724 audio_port_handle_t deviceId;
725 status_t status = data.readInt32(&deviceId);
726 if (status == NO_ERROR) {
727 reply->writeInt32(setInputDevice(deviceId));
728 } else {
729 reply->writeInt32(BAD_VALUE);
730 }
731 return NO_ERROR;
732 } break;
733 case GET_ROUTED_DEVICE_ID: {
734 ALOGV("GET_ROUTED_DEVICE_ID");
735 CHECK_INTERFACE(IMediaRecorder, data, reply);
736 audio_port_handle_t deviceId;
737 status_t status = getRoutedDeviceId(&deviceId);
738 reply->writeInt32(status);
739 if (status == NO_ERROR) {
740 reply->writeInt32(deviceId);
741 }
742 return NO_ERROR;
743 } break;
744 case ENABLE_AUDIO_DEVICE_CALLBACK: {
745 ALOGV("ENABLE_AUDIO_DEVICE_CALLBACK");
746 CHECK_INTERFACE(IMediaRecorder, data, reply);
747 bool enabled;
748 status_t status = data.readBool(&enabled);
749 if (status == NO_ERROR) {
750 reply->writeInt32(enableAudioDeviceCallback(enabled));
751 } else {
752 reply->writeInt32(BAD_VALUE);
753 }
754 return NO_ERROR;
755 } break;
756 case GET_ACTIVE_MICROPHONES: {
757 ALOGV("GET_ACTIVE_MICROPHONES");
758 CHECK_INTERFACE(IMediaRecorder, data, reply);
759 std::vector<media::MicrophoneInfo> activeMicrophones;
760 status_t status = getActiveMicrophones(&activeMicrophones);
761 reply->writeInt32(status);
762 if (status != NO_ERROR) {
763 return NO_ERROR;
764 }
765 reply->writeParcelableVector(activeMicrophones);
766 return NO_ERROR;
767
768 }
769 case GET_PORT_ID: {
770 ALOGV("GET_PORT_ID");
771 CHECK_INTERFACE(IMediaRecorder, data, reply);
772 audio_port_handle_t portId;
773 status_t status = getPortId(&portId);
774 reply->writeInt32(status);
775 if (status == NO_ERROR) {
776 reply->writeInt32(portId);
777 }
778 return NO_ERROR;
779 }
780 case GET_RTP_DATA_USAGE: {
781 ALOGV("GET_RTP_DATA_USAGE");
782 CHECK_INTERFACE(IMediaRecorder, data, reply);
783 uint64_t bytes;
784 status_t status = getRtpDataUsage(&bytes);
785 reply->writeInt32(status);
786 if (status == NO_ERROR) {
787 reply->writeUint64(bytes);
788 }
789 return NO_ERROR;
790 }
791 case SET_PREFERRED_MICROPHONE_DIRECTION: {
792 ALOGV("SET_PREFERRED_MICROPHONE_DIRECTION");
793 CHECK_INTERFACE(IMediaRecorder, data, reply);
794 int direction = data.readInt32();
795 status_t status = setPreferredMicrophoneDirection(
796 static_cast<audio_microphone_direction_t>(direction));
797 reply->writeInt32(status);
798 return NO_ERROR;
799 }
800 case SET_PREFERRED_MICROPHONE_FIELD_DIMENSION: {
801 ALOGV("SET_MICROPHONE_FIELD_DIMENSION");
802 CHECK_INTERFACE(IMediaRecorder, data, reply);
803 float zoom = data.readFloat();
804 status_t status = setPreferredMicrophoneFieldDimension(zoom);
805 reply->writeInt32(status);
806 return NO_ERROR;
807 }
808 default:
809 return BBinder::onTransact(code, data, reply, flags);
810 }
811 }
812
813 // ----------------------------------------------------------------------------
814
815 } // namespace android
816