/**@class android.media.MediaRecorder
 implements android.media.AudioRouting

 implements android.media.AudioRecordingMonitor

 implements android.media.AudioRecordingMonitorClient

 implements android.media.MicrophoneDirection

@extends java.lang.Object

 Used to record audio and video. The recording control is based on a
 simple state machine (see below).

 <p><img src="{@docRoot}images/mediarecorder_state_diagram.gif" border="0" />
 </p>

 <p>A common case of using MediaRecorder to record audio works as follows:

 <pre>MediaRecorder recorder = new MediaRecorder();
 recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
 recorder.setOutputFile(PATH_NAME);
 recorder.prepare();
 recorder.start();   // Recording is now started
 ...
 recorder.stop();
 recorder.reset();   // You can reuse the object by going back to setAudioSource() step
 recorder.release(); // Now the object cannot be reused
 </pre>

 <p>Applications may want to register for informational and error
 events in order to be informed of some internal update and possible
 runtime errors during recording. Registration for such events is
 done by setting the appropriate listeners (via calls
 (to {@link #setOnInfoListener}(OnInfoListener)setOnInfoListener and/or
 {@link #setOnErrorListener}(OnErrorListener)setOnErrorListener).
 In order to receive the respective callback associated with these listeners,
 applications are required to create MediaRecorder objects on threads with a
 Looper running (the main UI thread by default already has a Looper running).

 <p><strong>Note:</strong> Currently, MediaRecorder does not work on the emulator.

 <div class="special reference">
 <h3>Developer Guides</h3>
 <p>For more information about how to use MediaRecorder for recording video, read the
 <a href="{@docRoot}guide/topics/media/camera.html#capture-video">Camera</a> developer guide.
 For more information about how to use MediaRecorder for recording sound, read the
 <a href="{@docRoot}guide/topics/media/audio-capture.html">Audio Capture</a> developer guide.</p>
 </div>
*/
var MediaRecorder = {

/**Unspecified media recorder error.
 @see android.media.MediaRecorder.OnErrorListener
*/
MEDIA_RECORDER_ERROR_UNKNOWN : "1",
/**Media server died. In this case, the application must release the
 MediaRecorder object and instantiate a new one.
 @see android.media.MediaRecorder.OnErrorListener
*/
MEDIA_ERROR_SERVER_DIED : "100",
/**Unspecified media recorder info.
 @see android.media.MediaRecorder.OnInfoListener
*/
MEDIA_RECORDER_INFO_UNKNOWN : "1",
/**A maximum duration had been setup and has now been reached.
 @see android.media.MediaRecorder.OnInfoListener
*/
MEDIA_RECORDER_INFO_MAX_DURATION_REACHED : "800",
/**A maximum filesize had been setup and has now been reached.
 Note: This event will not be sent if application already set
 next output file through {@link #setNextOutputFile}.
 @see android.media.MediaRecorder.OnInfoListener
*/
MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED : "801",
/**A maximum filesize had been setup and current recorded file size
 has reached 90% of the limit. This is sent once per file upon
 reaching/passing the 90% limit. To continue the recording, applicaiton
 should use {@link #setNextOutputFile} to set the next output file.
 Otherwise, recording will stop when reaching maximum file size.
 @see android.media.MediaRecorder.OnInfoListener
*/
MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING : "802",
/**A maximum filesize had been reached and MediaRecorder has switched
 output to a new file set by application {@link #setNextOutputFile}.
 For best practice, application should use this event to keep track
 of whether the file previously set has been used or not.
 @see android.media.MediaRecorder.OnInfoListener
*/
MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED : "803",
/**informational events for individual tracks, for testing purpose.
 The track informational event usually contains two parts in the ext1
 arg of the onInfo() callback: bit 31-28 contains the track id; and
 the rest of the 28 bits contains the informational event defined here.
 For example, ext1 = (1 << 28 | MEDIA_RECORDER_TRACK_INFO_TYPE) if the
 track id is 1 for informational event MEDIA_RECORDER_TRACK_INFO_TYPE;
 while ext1 = (0 << 28 | MEDIA_RECORDER_TRACK_INFO_TYPE) if the track
 id is 0 for informational event MEDIA_RECORDER_TRACK_INFO_TYPE. The
 application should extract the track id and the type of informational
 event from ext1, accordingly.

 FIXME:
 Please update the comment for onInfo also when these
 events are unhidden so that application knows how to extract the track
 id and the informational event type from onInfo callback.

 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_LIST_START : "1000",
/**Signal the completion of the track for the recording session.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_COMPLETION_STATUS : "1000",
/**Indicate the recording progress in time (ms) during recording.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_PROGRESS_IN_TIME : "1001",
/**Indicate the track type: 0 for Audio and 1 for Video.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_TYPE : "1002",
/**Provide the track duration information.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_DURATION_MS : "1003",
/**Provide the max chunk duration in time (ms) for the given track.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_MAX_CHUNK_DUR_MS : "1004",
/**Provide the total number of recordd frames.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_ENCODED_FRAMES : "1005",
/**Provide the max spacing between neighboring chunks for the given track.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INTER_CHUNK_TIME_MS : "1006",
/**Provide the elapsed time measuring from the start of the recording
 till the first output frame of the given track is received, excluding
 any intentional start time offset of a recording session for the
 purpose of eliminating the recording sound in the recorded file.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_INITIAL_DELAY_MS : "1007",
/**Provide the start time difference (delay) betweeen this track and
 the start of the movie.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_START_OFFSET_MS : "1008",
/**Provide the total number of data (in kilo-bytes) encoded.
 {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_DATA_KBYTES : "1009",
/** {@hide}
*/
MEDIA_RECORDER_TRACK_INFO_LIST_END : "2000",
/**Sets a {@link android.hardware.Camera} to use for recording.

 <p>Use this function to switch quickly between preview and capture mode without a teardown of
 the camera object. {@link android.hardware.Camera#unlock()} should be called before
 this. Must call before {@link #prepare}.</p>
@param {Object {Camera}} c the Camera to use for recording
@deprecated Use {@link #getSurface} and the {@link android.hardware.camera2} API instead.
*/
setCamera : function(  ) {},

/**Gets the surface to record from when using SURFACE video source.

 <p> May only be called after {@link #prepare}. Frames rendered to the Surface before
 {@link #start} will be discarded.</p>
@throws IllegalStateException if it is called before {@link #prepare}, after
 {@link #stop}, or is called when VideoSource is not set to SURFACE.
@see android.media.MediaRecorder.VideoSource
*/
getSurface : function(  ) {},

/**Configures the recorder to use a persistent surface when using SURFACE video source.
 <p> May only be called before {@link #prepare}. If called, {@link #getSurface} should
 not be used and will throw IllegalStateException. Frames rendered to the Surface
 before {@link #start} will be discarded.</p>
@param {Object {Surface}} surface a persistent input surface created by
           {@link MediaCodec#createPersistentInputSurface}
@throws IllegalStateException if it is called after {@link #prepare} and before
 {@link #stop}.
@throws IllegalArgumentException if the surface was not created by
           {@link MediaCodec#createPersistentInputSurface}.
@see MediaCodec#createPersistentInputSurface
@see MediaRecorder.VideoSource
*/
setInputSurface : function(  ) {},

/**Sets a Surface to show a preview of recorded media (video). Calls this
 before prepare() to make sure that the desirable preview display is
 set. If {@link #setCamera}(Camera) is used and the surface has been
 already set to the camera, application do not need to call this. If
 this is called with non-null surface, the preview surface of the camera
 will be replaced by the new surface. If this method is called with null
 surface or not called at all, media recorder will not change the preview
 surface of the camera.
@param {Object {Surface}} sv the Surface to use for the preview
@see android.hardware.Camera#setPreviewDisplay(android.view.SurfaceHolder)
*/
setPreviewDisplay : function(  ) {},

/**
@param {Number} source An audio source to test
@param source An audio source to test
@return {Boolean} true if the source is only visible to system components
*/
isSystemOnlyAudioSource : function(  ) {},

/**
@hide 
*/
toLogFriendlyAudioSource : function(  ) {},

/**Sets the audio source to be used for recording. If this method is not
 called, the output file will not contain an audio track. The source needs
 to be specified before setting recording-parameters or encoders. Call
 this only before setOutputFormat().
@param {Number} audioSource the audio source to use
@throws IllegalStateException if it is called after setOutputFormat()
@see android.media.MediaRecorder.AudioSource
*/
setAudioSource : function(  ) {},

/**Gets the maximum value for audio sources.
@see android.media.MediaRecorder.AudioSource
*/
getAudioSourceMax : function(  ) {},

/**Sets the video source to be used for recording. If this method is not
 called, the output file will not contain an video track. The source needs
 to be specified before setting recording-parameters or encoders. Call
 this only before setOutputFormat().
@param {Number} video_source the video source to use
@throws IllegalStateException if it is called after setOutputFormat()
@see android.media.MediaRecorder.VideoSource
*/
setVideoSource : function(  ) {},

/**Uses the settings from a CamcorderProfile object for recording. This method should
 be called after the video AND audio sources are set, and before setOutputFile().
 If a time lapse CamcorderProfile is used, audio related source or recording
 parameters are ignored.
@param {Object {CamcorderProfile}} profile the CamcorderProfile to use
@see android.media.CamcorderProfile
*/
setProfile : function(  ) {},

/**Set video frame capture rate. This can be used to set a different video frame capture
 rate than the recorded video's playback rate. This method also sets the recording mode
 to time lapse. In time lapse video recording, only video is recorded. Audio related
 parameters are ignored when a time lapse recording session starts, if an application
 sets them.
@param {Number} fps Rate at which frames should be captured in frames per second.
 The fps can go as low as desired. However the fastest fps will be limited by the hardware.
 For resolutions that can be captured by the video camera, the fastest fps can be computed using
 {@link android.hardware.Camera.Parameters#getPreviewFpsRange(int[])}. For higher
 resolutions the fastest fps may be more restrictive.
 Note that the recorder cannot guarantee that frames will be captured at the
 given rate due to camera/encoder limitations. However it tries to be as close as
 possible.
*/
setCaptureRate : function(  ) {},

/**Sets the orientation hint for output video playback.
 This method should be called before prepare(). This method will not
 trigger the source video frame to rotate during video recording, but to
 add a composition matrix containing the rotation angle in the output
 video if the output format is OutputFormat.THREE_GPP or
 OutputFormat.MPEG_4 so that a video player can choose the proper
 orientation for playback. Note that some video players may choose
 to ignore the compostion matrix in a video during playback.
@param {Number} degrees the angle to be rotated clockwise in degrees.
 The supported angles are 0, 90, 180, and 270 degrees.
@throws IllegalArgumentException if the angle is not supported.
*/
setOrientationHint : function(  ) {},

/**Set and store the geodata (latitude and longitude) in the output file.
 This method should be called before prepare(). The geodata is
 stored in udta box if the output format is OutputFormat.THREE_GPP
 or OutputFormat.MPEG_4, and is ignored for other output formats.
 The geodata is stored according to ISO-6709 standard.
@param {Number} latitude latitude in degrees. Its value must be in the
 range [-90, 90].
@param {Number} longitude longitude in degrees. Its value must be in the
 range [-180, 180].
@throws IllegalArgumentException if the given latitude or
 longitude is out of range.
*/
setLocation : function(  ) {},

/**Sets the format of the output file produced during recording. Call this
 after setAudioSource()/setVideoSource() but before prepare().

 <p>It is recommended to always use 3GP format when using the H.263
 video encoder and AMR audio encoder. Using an MPEG-4 container format
 may confuse some desktop players.</p>
@param {Number} output_format the output format to use. The output format
 needs to be specified before setting recording-parameters or encoders.
@throws IllegalStateException if it is called after prepare() or before
 setAudioSource()/setVideoSource().
@see android.media.MediaRecorder.OutputFormat
*/
setOutputFormat : function(  ) {},

/**Sets the width and height of the video to be captured.  Must be called
 after setVideoSource(). Call this after setOutFormat() but before
 prepare().
@param {Number} width the width of the video to be captured
@param {Number} height the height of the video to be captured
@throws IllegalStateException if it is called after
 prepare() or before setOutputFormat()
*/
setVideoSize : function(  ) {},

/**Sets the frame rate of the video to be captured.  Must be called
 after setVideoSource(). Call this after setOutFormat() but before
 prepare().
@param {Number} rate the number of frames per second of video to capture
@throws IllegalStateException if it is called after
 prepare() or before setOutputFormat().

 NOTE: On some devices that have auto-frame rate, this sets the
 maximum frame rate, not a constant frame rate. Actual frame rate
 will vary according to lighting conditions.
*/
setVideoFrameRate : function(  ) {},

/**Sets the maximum duration (in ms) of the recording session.
 Call this after setOutFormat() but before prepare().
 After recording reaches the specified duration, a notification
 will be sent to the {@link android.media.MediaRecorder.OnInfoListener}
 with a "what" code of {@link #MEDIA_RECORDER_INFO_MAX_DURATION_REACHED}
 and recording will be stopped. Stopping happens asynchronously, there
 is no guarantee that the recorder will have stopped by the time the
 listener is notified.

 <p>When using MPEG-4 container ({@link #setOutputFormat}(int) with
 {@link android.media.MediaMuxer.OutputFormat#MPEG_4}), it is recommended to set maximum duration that fits the use
 case. Setting a larger than required duration may result in a larger than needed output file
 because of space reserved for MOOV box expecting large movie data in this recording session.
  Unused space of MOOV box is turned into FREE box in the output file.</p>
@param {Number} max_duration_ms the maximum duration in ms (if zero or negative, disables the duration limit)
*/
setMaxDuration : function(  ) {},

/**Sets the maximum filesize (in bytes) of the recording session.
 Call this after setOutFormat() but before prepare().
 After recording reaches the specified filesize, a notification
 will be sent to the {@link android.media.MediaRecorder.OnInfoListener}
 with a "what" code of {@link #MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED}
 and recording will be stopped. Stopping happens asynchronously, there
 is no guarantee that the recorder will have stopped by the time the
 listener is notified.

 <p>When using MPEG-4 container ({@link #setOutputFormat}(int) with
 {@link android.media.MediaMuxer.OutputFormat#MPEG_4}), it is recommended to set maximum filesize that fits the use
 case. Setting a larger than required filesize may result in a larger than needed output file
 because of space reserved for MOOV box expecting large movie data in this recording session.
 Unused space of MOOV box is turned into FREE box in the output file.</p>
@param {Number} max_filesize_bytes the maximum filesize in bytes (if zero or negative, disables the limit)
*/
setMaxFileSize : function(  ) {},

/**Sets the audio encoder to be used for recording. If this method is not
 called, the output file will not contain an audio track. Call this after
 setOutputFormat() but before prepare().
@param {Number} audio_encoder the audio encoder to use.
@throws IllegalStateException if it is called before
 setOutputFormat() or after prepare().
@see android.media.MediaRecorder.AudioEncoder
*/
setAudioEncoder : function(  ) {},

/**Sets the video encoder to be used for recording. If this method is not
 called, the output file will not contain an video track. Call this after
 setOutputFormat() and before prepare().
@param {Number} video_encoder the video encoder to use.
@throws IllegalStateException if it is called before
 setOutputFormat() or after prepare()
@see android.media.MediaRecorder.VideoEncoder
*/
setVideoEncoder : function(  ) {},

/**Sets the audio sampling rate for recording. Call this method before prepare().
 Prepare() may perform additional checks on the parameter to make sure whether
 the specified audio sampling rate is applicable. The sampling rate really depends
 on the format for the audio recording, as well as the capabilities of the platform.
 For instance, the sampling rate supported by AAC audio coding standard ranges
 from 8 to 96 kHz, the sampling rate supported by AMRNB is 8kHz, and the sampling
 rate supported by AMRWB is 16kHz. Please consult with the related audio coding
 standard for the supported audio sampling rate.
@param {Number} samplingRate the sampling rate for audio in samples per second.
*/
setAudioSamplingRate : function(  ) {},

/**Sets the number of audio channels for recording. Call this method before prepare().
 Prepare() may perform additional checks on the parameter to make sure whether the
 specified number of audio channels are applicable.
@param {Number} numChannels the number of audio channels. Usually it is either 1 (mono) or 2
 (stereo).
*/
setAudioChannels : function(  ) {},

/**Sets the audio encoding bit rate for recording. Call this method before prepare().
 Prepare() may perform additional checks on the parameter to make sure whether the
 specified bit rate is applicable, and sometimes the passed bitRate will be clipped
 internally to ensure the audio recording can proceed smoothly based on the
 capabilities of the platform.
@param {Number} bitRate the audio encoding bit rate in bits per second.
*/
setAudioEncodingBitRate : function(  ) {},

/**Sets the video encoding bit rate for recording. Call this method before prepare().
 Prepare() may perform additional checks on the parameter to make sure whether the
 specified bit rate is applicable, and sometimes the passed bitRate will be
 clipped internally to ensure the video recording can proceed smoothly based on
 the capabilities of the platform.
@param {Number} bitRate the video encoding bit rate in bits per second.
*/
setVideoEncodingBitRate : function(  ) {},

/**Sets the desired video encoding profile and level for recording. The profile and level
 must be valid for the video encoder set by {@link #setVideoEncoder}. This method can
 called before or after {@link #setVideoEncoder} but it must be called before {@link #prepare}.
 {@code prepare()} may perform additional checks on the parameter to make sure that the specified
 profile and level are applicable, and sometimes the passed profile or level will be
 discarded due to codec capablity or to ensure the video recording can proceed smoothly
 based on the capabilities of the platform. <br>Application can also use the
 {@link android.media.MediaCodecInfo.CodecCapabilities#profileLevels} to query applicable combination of profile
 and level for the corresponding format. Note that the requested profile/level may not be supported by
 the codec that is actually being used by this MediaRecorder instance.
@param {Number} profile declared in {@link MediaCodecInfo.CodecProfileLevel}.
@param {Number} level declared in {@link MediaCodecInfo.CodecProfileLevel}.
@throws IllegalArgumentException when an invalid profile or level value is used.
*/
setVideoEncodingProfileLevel : function(  ) {},

/**Currently not implemented. It does nothing.
@deprecated Time lapse mode video recording using camera still image capture
 is not desirable, and will not be supported.
@hide 
*/
setAuxiliaryOutputFile : function(  ) {},

/**Currently not implemented. It does nothing.
@deprecated Time lapse mode video recording using camera still image capture
 is not desirable, and will not be supported.
@hide 
*/
setAuxiliaryOutputFile : function(  ) {},

/**Pass in the file descriptor of the file to be written. Call this after
 setOutputFormat() but before prepare().
@param {Object {FileDescriptor}} fd an open file descriptor to be written into.
@throws IllegalStateException if it is called before
 setOutputFormat() or after prepare()
*/
setOutputFile : function(  ) {},

/**Pass in the file object to be written. Call this after setOutputFormat() but before prepare().
 File should be seekable. After setting the next output file, application should not use the
 file until {@link #stop}. Application is responsible for cleaning up unused files after
 {@link #stop} is called.
@param {Object {File}} file the file object to be written into.
*/
setOutputFile : function(  ) {},

/**Sets the next output file descriptor to be used when the maximum filesize is reached
 on the prior output {@link #setOutputFile} or {@link #setNextOutputFile}). File descriptor
 must be seekable and writable. After setting the next output file, application should not
 use the file referenced by this file descriptor until {@link #stop}. It is the application's
 responsibility to close the file descriptor. It is safe to do so as soon as this call returns.
 Application must call this after receiving on the
 {@link android.media.MediaRecorder.OnInfoListener} a "what" code of
 {@link #MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING} and before receiving a "what" code of
 {@link #MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED}. The file is not used until switching to
 that output. Application will receive{@link #MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED}
 when the next output file is used. Application will not be able to set a new output file if
 the previous one has not been used. Application is responsible for cleaning up unused files
 after {@link #stop} is called.
@param {Object {FileDescriptor}} fd an open file descriptor to be written into.
@throws IllegalStateException if it is called before prepare().
@throws IOException if setNextOutputFile fails otherwise.
*/
setNextOutputFile : function(  ) {},

/**Sets the path of the output file to be produced. Call this after
 setOutputFormat() but before prepare().
@param {String} path The pathname to use.
@throws IllegalStateException if it is called before
 setOutputFormat() or after prepare()
*/
setOutputFile : function(  ) {},

/**Sets the next output file to be used when the maximum filesize is reached on the prior
 output {@link #setOutputFile} or {@link #setNextOutputFile}). File should be seekable.
 After setting the next output file, application should not use the file until {@link #stop}.
 Application must call this after receiving on the
 {@link android.media.MediaRecorder.OnInfoListener} a "what" code of
 {@link #MEDIA_RECORDER_INFO_MAX_FILESIZE_APPROACHING} and before receiving a "what" code of
 {@link #MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED}. The file is not used until switching to
 that output. Application will receive {@link #MEDIA_RECORDER_INFO_NEXT_OUTPUT_FILE_STARTED}
 when the next output file is used. Application will not be able to set a new output file if
 the previous one has not been used. Application is responsible for cleaning up unused files
 after {@link #stop} is called.
@param {Object {File}} file The file to use.
@throws IllegalStateException if it is called before prepare().
@throws IOException if setNextOutputFile fails otherwise.
*/
setNextOutputFile : function(  ) {},

/**Prepares the recorder to begin capturing and encoding data. This method
 must be called after setting up the desired audio and video sources,
 encoders, file format, etc., but before start().
@throws IllegalStateException if it is called after
 start() or before setOutputFormat().
@throws IOException if prepare fails otherwise.
*/
prepare : function(  ) {},

/**Begins capturing and encoding data to the file specified with
 setOutputFile(). Call this after prepare().

 <p>Since API level 13, if applications set a camera via
 {@link #setCamera}(Camera), the apps can use the camera after this method
 call. The apps do not need to lock the camera again. However, if this
 method fails, the apps should still lock the camera back. The apps should
 not start another recording session during recording.
@throws IllegalStateException if it is called before
 prepare() or when the camera is already in use by another app.
*/
start : function(  ) {},

/**Stops recording. Call this after start(). Once recording is stopped,
 you will have to configure it again as if it has just been constructed.
 Note that a RuntimeException is intentionally thrown to the
 application, if no valid audio/video data has been received when stop()
 is called. This happens if stop() is called immediately after
 start(). The failure lets the application take action accordingly to
 clean up the output file (delete the output file, for instance), since
 the output file is not properly constructed when this happens.
@throws IllegalStateException if it is called before start()
*/
stop : function(  ) {},

/**Pauses recording. Call this after start(). You may resume recording
 with resume() without reconfiguration, as opposed to stop(). It does
 nothing if the recording is already paused.

 When the recording is paused and resumed, the resulting output would
 be as if nothing happend during paused period, immediately switching
 to the resumed scene.
@throws IllegalStateException if it is called before start() or after
 stop()
*/
pause : function(  ) {},

/**Resumes recording. Call this after start(). It does nothing if the
 recording is not paused.
@throws IllegalStateException if it is called before start() or after
 stop()
@see android.media.MediaRecorder#pause
*/
resume : function(  ) {},

/**Restarts the MediaRecorder to its idle state. After calling
 this method, you will have to configure it again as if it had just been
 constructed.
*/
reset : function(  ) {},

/**Returns the maximum absolute amplitude that was sampled since the last
 call to this method. Call this only after the setAudioSource().
@return {Number} the maximum absolute amplitude measured since the last call, or
 0 when called for the first time
@throws IllegalStateException if it is called before
 the audio source has been set.
*/
getMaxAmplitude : function(  ) {},

/**Register a callback to be invoked when an error occurs while
 recording.
@param {Object {MediaRecorder.OnErrorListener}} l the callback that will be run
*/
setOnErrorListener : function(  ) {},

/**Register a callback to be invoked when an informational event occurs while
 recording.
@param {Object {MediaRecorder.OnInfoListener}} listener the callback that will be run
*/
setOnInfoListener : function(  ) {},

/**Specifies an audio device (via an {@link android.media.AudioDeviceInfo} object) to route
 the input from this MediaRecorder.
@param {Object {AudioDeviceInfo}} deviceInfo The {@link AudioDeviceInfo} specifying the audio source.
  If deviceInfo is null, default routing is restored.
@return {Boolean} true if succesful, false if the specified {@link AudioDeviceInfo} is non-null and
 does not correspond to a valid audio input device.
*/
setPreferredDevice : function(  ) {},

/**Returns the selected input device specified by {@link #setPreferredDevice}. Note that this
 is not guaranteed to correspond to the actual device being used for recording.
*/
getPreferredDevice : function(  ) {},

/**Returns an {@link android.media.AudioDeviceInfo} identifying the current routing of this MediaRecorder
 Note: The query is only valid if the MediaRecorder is currently recording.
 If the recorder is not recording, the returned device can be null or correspond to previously
 selected device when the recorder was last active.
*/
getRoutedDevice : function(  ) {},

/**Adds an {@link android.media.AudioRouting.OnRoutingChangedListener} to receive notifications of routing
 changes on this MediaRecorder.
@param {Object {AudioRouting.OnRoutingChangedListener}} listener The {@link AudioRouting.OnRoutingChangedListener} interface to receive
 notifications of rerouting events.
@param {Object {Handler}} handler  Specifies the {@link Handler} object for the thread on which to execute
 the callback. If <code>null</code>, the handler on the main looper will be used.
*/
addOnRoutingChangedListener : function(  ) {},

/**Removes an {@link android.media.AudioRouting.OnRoutingChangedListener} which has been previously added
 to receive rerouting notifications.
@param {Object {AudioRouting.OnRoutingChangedListener}} listener The previously added {@link AudioRouting.OnRoutingChangedListener} interface
 to remove.
*/
removeOnRoutingChangedListener : function(  ) {},

/**Return A lists of {@link android.media.MicrophoneInfo} representing the active microphones.
 By querying channel mapping for each active microphone, developer can know how
 the microphone is used by each channels or a capture stream.
@return {Object {java.util.List}} a lists of {@link MicrophoneInfo} representing the active microphones
@throws IOException if an error occurs
*/
getActiveMicrophones : function(  ) {},

/**Specifies the logical microphone (for processing).
@param {Number} direction Direction constant.
@return {Boolean} true if sucessful.
*/
setPreferredMicrophoneDirection : function(  ) {},

/**Specifies the zoom factor (i.e. the field dimension) for the selected microphone
 (for processing). The selected microphone is determined by the use-case for the stream.
@param {Number} zoom the desired field dimension of microphone capture. Range is from -1 (wide angle),
 though 0 (no zoom) to 1 (maximum zoom).
@return {Boolean} true if sucessful.
*/
setPreferredMicrophoneFieldDimension : function(  ) {},

/**Register a callback to be notified of audio capture changes via a
 {@link android.media.AudioManager.AudioRecordingCallback}. A callback is received when the capture path
 configuration changes (pre-processing, format, sampling rate...) or capture is
 silenced/unsilenced by the system.
@param {Object {Executor}} executor {@link Executor} to handle the callbacks.
@param {Object {AudioManager.AudioRecordingCallback}} cb non-null callback to register
*/
registerAudioRecordingCallback : function(  ) {},

/**Unregister an audio recording callback previously registered with
 {@link #registerAudioRecordingCallback(Executor, android.media.AudioManager.AudioRecordingCallback)}.
@param {Object {AudioManager.AudioRecordingCallback}} cb non-null callback to unregister
*/
unregisterAudioRecordingCallback : function(  ) {},

/**Returns the current active audio recording for this audio recorder.
@return {Object {android.media.AudioRecordingConfiguration}} a valid {@link AudioRecordingConfiguration} if this recorder is active
 or null otherwise.
@see AudioRecordingConfiguration
*/
getActiveRecordingConfiguration : function(  ) {},

/**
@hide 
*/
getPortId : function(  ) {},

/**Releases resources associated with this MediaRecorder object.
 It is good practice to call this method when you're done
 using the MediaRecorder. In particular, whenever an Activity
 of an application is paused (its onPause() method is called),
 or stopped (its onStop() method is called), this method should be
 invoked to release the MediaRecorder object, unless the application
 has a special need to keep the object around. In addition to
 unnecessary resources (such as memory and instances of codecs)
 being held, failure to call this method immediately if a
 MediaRecorder object is no longer needed may also lead to
 continuous battery consumption for mobile devices, and recording
 failure for other applications if no multiple instances of the
 same codec are supported on a device. Even if multiple instances
 of the same codec are supported, some performance degradation
 may be expected when unnecessary multiple instances are used
 at the same time.
*/
release : function(  ) {},

/**Return Metrics data about the current Mediarecorder instance.
@return {Object {android.os.PersistableBundle}} a {@link PersistableBundle} containing the set of attributes and values
 available for the media being generated by this instance of
 MediaRecorder.
 The attributes are descibed in {@link MetricsConstants}.

  Additional vendor-specific fields may also be present in
  the return value.
*/
getMetrics : function(  ) {},


};