public void StartRecorder()
{
try {
//Java.IO.File sdDir = Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryMusic);
//filePath = sdDir + "/" + "testAudio.mp3";
if (File.Exists (filePath))
File.Delete (filePath);
//Java.IO.File myFile = new Java.IO.File(filePath);
//myFile.CreateNewFile();
if (recorder == null)
recorder = new MediaRecorder (); // Initial state.
else
recorder.Reset ();
recorder.SetAudioSource (AudioSource.Mic);
recorder.SetOutputFormat (OutputFormat.Mpeg4);
recorder.SetAudioEncoder (AudioEncoder.AmrNb); // Initialized state.
recorder.SetOutputFile (filePath); // DataSourceConfigured state.
recorder.Prepare (); // Prepared state
recorder.Start (); // Recording state.
} catch (Exception ex) {
Console.Out.WriteLine (ex.StackTrace);
}
}
protected override IEnumerable<Datum> Poll(CancellationToken cancellationToken)
{
MediaRecorder recorder = null;
try
{
recorder = new MediaRecorder();
recorder.SetAudioSource(AudioSource.Mic);
recorder.SetOutputFormat(OutputFormat.ThreeGpp);
recorder.SetAudioEncoder(AudioEncoder.AmrNb);
recorder.SetOutputFile("/dev/null");
recorder.Prepare();
recorder.Start();
// mark start time of amplitude measurement -- MaxAmplitude is always computed from previous call to MaxAmplitude
int dummy = recorder.MaxAmplitude;
Thread.Sleep(SampleLengthMS);
return new Datum[] { new SoundDatum(DateTimeOffset.UtcNow, 20 * Math.Log10(recorder.MaxAmplitude)) }; // http://www.mathworks.com/help/signal/ref/mag2db.html
}
finally
{
if (recorder != null)
{
try { recorder.Stop(); }
catch (Exception) { }
try { recorder.Release(); }
catch (Exception) { }
}
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
var outputFile = System.IO.Path.Combine(Android.OS.Environment.ExternalStorageDirectory.ToString(),
"myvideooutputfile.mp4");
if (!recording)
{
mediaRecorder = new MediaRecorder();
//correctCamera();
//if (camera != null)
// mediaRecorder.SetCamera(camera);
mediaRecorder.SetAudioSource(AudioSource.Mic);
mediaRecorder.SetVideoSource(VideoSource.Camera);
mediaRecorder.SetOutputFormat(OutputFormat.ThreeGpp);
mediaRecorder.SetAudioEncoder(AudioEncoder.Aac);
mediaRecorder.SetVideoEncoder(VideoEncoder.Mpeg4Sp);
if (System.IO.File.Exists(outputFile))
System.IO.File.Delete(outputFile);
System.IO.File.Create(outputFile);
CamcorderProfile camProf = CamcorderProfile.Get(CamcorderQuality.Low);
fps = camProf.VideoFrameRate;
mediaRecorder.SetOutputFile(outputFile);
mediaRecorder.SetPreviewDisplay(holder.Surface);
mediaRecorder.Prepare();
} else
{
mediaPlayer.SetDisplay(holder);
mediaPlayer.SetDataSource(outputFile);
mediaPlayer.Prepared += new EventHandler(mediaPlayer_Prepared);
mediaPlayer.PrepareAsync();
}
}
public void StopRecorder()
{
if (recorder != null) {
recorder.Stop ();
recorder.Release ();
recorder = null;
}
}
public bool RecordAudio()
{
if (string.IsNullOrEmpty(folder) || string.IsNullOrEmpty(directoryname))
{
return false;
}
//--test
// get all under root:
/*
var directories = Directory.EnumerateDirectories("./");
foreach (var directory in directories)
{
Console.WriteLine(directory);
}
*/
// read text file:
/*
var text = File.ReadAllText("TestData/ReadMe.txt");
Console.WriteLine(text);
*/
// xml stream reader:
/*
using (TextReader reader = new StreamReader("./TestData/test.xml"))
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(MyObject));
var xml = (MyObject)serializer.Deserialize(reader);
}
*/
try
{
Directory.CreateDirectory(directoryname);
fileName = string.Format("Audio{0}.aac", DateTime.Now.ToString("yyyyMMddHHmmss"));
path = Path.Combine(directoryname, fileName);
_recorder = new MediaRecorder();
_recorder.Reset();
_recorder.SetAudioSource(AudioSource.Mic);
_recorder.SetOutputFormat(OutputFormat.Default);
_recorder.SetAudioEncoder(AudioEncoder.Aac);
_recorder.SetOutputFile(path);
_recorder.Prepare();
_recorder.Start();
return true;
}
catch (System.Exception ex)
{
_recorder = null;
fileName = string.Empty;
var test = ex.Message;
return false;
}
}
public void Pause()
{
_player.Release();
_recorder.Release();
_player.Dispose();
_recorder.Dispose();
_player = null;
_recorder = null;
}
public void StopRecording()
{
// stop recording
_mic.Stop();
// prepare object for GC by calling dispose
_mic.Release();
_mic = null;
}
protected override void OnDestroy()
{
base.OnDestroy ();
if (recorder != null) {
recorder.Release ();
recorder.Dispose ();
recorder = null;
}
}
protected override void OnPause()
{
base.OnPause();
_player.Release();
_recorder.Release();
_player.Dispose();
_recorder.Dispose();
_player = null;
_recorder = null;
}
public void RecordSound()
{
_url = StorageService.GenerateFilename(StorageType.Sound, "3gpp");
_recorder = new MediaRecorder();
_recorder.SetAudioSource(AudioSource.Mic);
_recorder.SetOutputFormat(OutputFormat.ThreeGpp);
_recorder.SetAudioEncoder(AudioEncoder.AmrNb);
_recorder.SetOutputFile(_url);
_recorder.Prepare();
_recorder.Start();
}
protected override void OnResume()
{
base.OnResume ();
_recorder = new MediaRecorder ();
_player = new MediaPlayer ();
_player.Completion += (sender, e) => {
_player.Reset ();
_start.Enabled = !_start.Enabled;
};
}
protected override void OnResume()
{
base.OnResume();
_recorder = new MediaRecorder();
_player = new MediaPlayer();
_player.Completion += (sender, e) =>
{
_player.Reset();
_btnRecord.Enabled = true;
_btnPlay.Enabled = true;
};
}
public void Resume()
{
//base.OnResume();
_recorder = new MediaRecorder();
_player = new MediaPlayer();
_player.Completion += (sender, e) =>
{
_player.Reset();
MessagingCenter.Send<ISoundRecorder>(this, "MediaPlayer.Complete");
};
}
private void releaseMediaRecorder()
{
if (mMediaRecorder != null)
{
// clear recorder configuration
mMediaRecorder.Reset();
// release the recorder object
mMediaRecorder.Release();
mMediaRecorder = null;
// Lock camera for later use i.e taking it back from MediaRecorder.
// MediaRecorder doesn't need it anymore and we will release it if the activity pauses.
mCamera.Lock();
}
}
public void SetUpRecoder()
{
try
{
if (null == activity)
{
return;
}
if (userResponse == UserResponse.Video)
{
mediaRecorder = new MediaRecorder();
mediaRecorder.Reset();
mediaRecorder.SetAudioSource(AudioSource.Mic);
mediaRecorder.SetVideoSource(VideoSource.Surface);
mediaRecorder.SetOutputFormat(OutputFormat.Mpeg4);
mediaRecorder.SetOutputFile(path + "/test.mp4");
mediaRecorder.SetVideoEncodingBitRate(10000000);
mediaRecorder.SetVideoFrameRate(30);
mediaRecorder.SetVideoSize(videoSize.Width, videoSize.Height);
mediaRecorder.SetVideoEncoder(VideoEncoder.H264);
mediaRecorder.SetAudioEncoder(AudioEncoder.Aac);
//int rotation = (int)activity.WindowManager.DefaultDisplay.Rotation;
//int orientation = ORIENTATIONS.Get(rotation);
if (LensFacing == CameraFacing.BACK)
{
mediaRecorder.SetOrientationHint(90);
}
else
{
mediaRecorder.SetOrientationHint(270);
}
mediaRecorder.SetMaxDuration(30000);
mediaRecorder.Prepare();
}
else
{
mediaRecorder = new MediaRecorder();
mediaRecorder.Reset();
mediaRecorder.SetAudioSource(AudioSource.Mic);
mediaRecorder.SetOutputFormat(OutputFormat.ThreeGpp);
mediaRecorder.SetAudioEncoder(AudioEncoder.AmrNb);
mediaRecorder.SetOutputFile(path + "/test.mp3");
mediaRecorder.SetMaxDuration(30000);
mediaRecorder.Prepare();
}
}
catch (System.Exception ex)
{
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
mediaRecord = new MediaRecorder ();
mediaRecord.SetAudioSource (AudioSource.Mic);
mediaRecord.SetVideoSource (VideoSource.Camera);
mediaRecord.SetOutputFormat (OutputFormat.Default);
mediaRecord.SetAudioEncoder (AudioEncoder.Default);
mediaRecord.SetVideoEncoder (VideoEncoder.Default);
System.IO.File.Create (videoFilename);
mediaRecord.SetOutputFile (videoFilename);
mediaRecord.SetPreviewDisplay (holder.Surface);
mediaRecord.Prepare ();
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
SetContentView (Resource.Layout.video);
string path = Android.OS.Environment.ExternalStorageDirectory.AbsolutePath + "/test.mp4";
var record = FindViewById<Button> (Resource.Id.Record);
var stop = FindViewById<Button> (Resource.Id.Stop);
var play = FindViewById<Button> (Resource.Id.Play);
var video = FindViewById<VideoView> (Resource.Id.SampleVideoView);
record.Click += delegate {
video.StopPlayback ();
recorder = new MediaRecorder ();
recorder.SetVideoSource (VideoSource.Camera);
recorder.SetAudioSource (AudioSource.Mic);
recorder.SetOutputFormat (OutputFormat.Default);
recorder.SetVideoEncoder (VideoEncoder.Default);
recorder.SetAudioEncoder (AudioEncoder.Default);
recorder.SetOutputFile (path);
recorder.SetPreviewDisplay (video.Holder.Surface);
recorder.Prepare ();
recorder.Start ();
};
stop.Click += delegate {
if (recorder != null) {
recorder.Stop ();
recorder.Release ();
}
};
play.Click += delegate {
var uri = Android.Net.Uri.Parse (path);
video.SetVideoURI (uri);
video.Start ();
};
}
public void SetVideo()
{
var recorder = new Android.Media.MediaRecorder();
recorder.SetAudioSource(AudioSource.Mic);
recorder.SetVideoSource(VideoSource.Surface);
recorder.SetOutputFormat(OutputFormat.Mpeg4);
recorder.SetVideoEncodingBitRate(10000000);
recorder.SetVideoFrameRate(30);
recorder.SetVideoEncoder(VideoEncoder.H264);
recorder.SetAudioEncoder(AudioEncoder.Aac);
recorder.SetVideoSize(_previewSize.Width, _previewSize.Height);
SurfaceOrientation rotation = windowManager.DefaultDisplay.Rotation;
recorder.SetOrientationHint();
var pfd = new ParcelFileDescriptor(ParcelFileDescriptor.FromSocket(new Socket()));
recorder.SetOutputFile(pfd.FileDescriptor);
#region sample
/*mediaRecorder.SetAudioSource(AudioSource.Mic);
* mediaRecorder.SetVideoSource(VideoSource.Surface);
* mediaRecorder.SetOutputFormat(OutputFormat.Mpeg4);
* mediaRecorder.SetOutputFile(GetVideoFile(Activity).AbsolutePath);
* mediaRecorder.SetVideoEncodingBitRate(10000000);
* mediaRecorder.SetVideoFrameRate(30);
* mediaRecorder.SetVideoSize(videoSize.Width, videoSize.Height);
* mediaRecorder.SetVideoEncoder(VideoEncoder.H264);
* mediaRecorder.SetAudioEncoder(AudioEncoder.Aac);
* int rotation = (int)Activity.WindowManager.DefaultDisplay.Rotation;
* int orientation = ORIENTATIONS.Get(rotation);
* mediaRecorder.SetOrientationHint(orientation); //
* mediaRecorder.Prepare();*/
#endregion
}
public void StopRecorder()
{
try
{
IsRecorderStop = true;
IsRecorderPlaying = false;
if (timer != null)
{
timer.Stop();
timer.Dispose();
timer = null;
}
if (mediaRecorder != null)
{
mediaRecorder.Stop();
mediaRecorder.Release();
mediaRecorder.Dispose();
mediaRecorder = null;
}
}
catch (System.Exception ex)
{
}
}
public void stopRecordingVideo()
{
//UI
is_recording_video = false;
button_video.SetText (Resource.String.record);
//Stop recording
media_recorder.Stop ();
media_recorder.Release ();
media_recorder = null;
if (null != Activity) {
Toast.MakeText (Activity, "Video saved: " + getVideoFile (Activity),
ToastLength.Short).Show ();
}
startPreview ();
}
private void startRecordingVideo() {
if (null == Activity)
return;
media_recorder = new MediaRecorder ();
File file = getVideoFile (Activity);
try {
//UI
button_video.SetText (Resource.String.stop);
is_recording_video = true;
//Configure the MediaRecorder
media_recorder.SetAudioSource (AudioSource.Mic);
media_recorder.SetVideoSource (VideoSource.Surface);
media_recorder.SetOutputFormat (OutputFormat.Mpeg4);
media_recorder.SetOutputFile (System.IO.Path.GetFullPath (file.ToString()));
media_recorder.SetVideoEncodingBitRate (10000000);
media_recorder.SetVideoFrameRate (30);
media_recorder.SetVideoSize (1440, 1080);
media_recorder.SetVideoEncoder (VideoEncoder.H264);
media_recorder.SetAudioEncoder (AudioEncoder.Aac);
int rotation = (int)Activity.WindowManager.DefaultDisplay.Rotation;
int orientation = ORIENTATIONS.Get (rotation);
media_recorder.SetOrientationHint (orientation);
media_recorder.Prepare ();
Surface surface = media_recorder.Surface;
//Set up CaptureRequest
builder = camera_device.CreateCaptureRequest (CameraTemplate.Record);
builder.AddTarget (surface);
var preview_surface = new Surface (texture_view.SurfaceTexture);
builder.AddTarget (preview_surface);
var surface_list = new List<Surface>();
surface_list.Add(surface);
surface_list.Add(preview_surface);
camera_device.CreateCaptureSession(surface_list,new RecordingCaptureStateListener(this),null);
} catch (IOException e) {
e.PrintStackTrace ();
} catch (CameraAccessException e) {
e.PrintStackTrace ();
} catch (IllegalStateException e) {
e.PrintStackTrace ();
}
}
protected override void OnResume()
{
base.OnResume ();
_recorder = new MediaRecorder ();
_player = new MediaPlayer ();
_player.Completion += (sender, e) => {
_player.Reset ();
};
_photoAdapter.NotifyDataSetChanged ();
_recordAdapter.NotifyDataSetChanged ();
}
public void StartRecording()
{
var documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
_recordedFileName = documents + File.PathSeparator + Guid.NewGuid() + ".mp4";
ClearMediaRecorder();
_mediaRecorder = new MediaRecorder();
_mediaRecorder.SetAudioSource(AudioSource.Default);
_mediaRecorder.SetOutputFormat(OutputFormat.Mpeg4);
_mediaRecorder.SetAudioEncoder(AudioEncoder.Aac);
_mediaRecorder.SetOutputFile(_recordedFileName);
_mediaRecorder.Prepare();
_mediaRecorder.Start();
}
public RecordAdapter()
{
recorder = new MediaRecorder();
if (!Directory.Exists(FILE_PATH))
Directory.CreateDirectory(FILE_PATH);
}
public void OnStart(MediaRecorder recorder)
{
try
{
recorder.Start();
} catch (Java.Lang.RuntimeException e)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("Runtime Exception thrown : {0}, {1}", e.Message, e.StackTrace);
#endif
failed = true;
} catch (Java.Lang.Exception es)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("Exception thown : {0}, {1}", es.Message, es.StackTrace);
#endif
failed = true;
}
#if DEBUG
System.Diagnostics.Debug.WriteLine("failed = {0}", failed);
#endif
}
private void ClearMediaRecorder()
{
if (_mediaRecorder != null)
{
_mediaRecorder.Release();
_mediaRecorder = null;
}
}
public AndroidAudioRecorder()
{
Recorder = new MediaRecorder ();
}
//Tries to open a CameraDevice
public void openCamera(int width, int height)
{
if (null == Activity || Activity.IsFinishing)
return;
CameraManager manager = (CameraManager)Activity.GetSystemService (Context.CameraService);
try {
if(!cameraOpenCloseLock.TryAcquire(2500,TimeUnit.Milliseconds))
throw new RuntimeException("Time out waiting to lock camera opening.");
string cameraId = manager.GetCameraIdList()[0];
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))));
previewSize = ChooseOptimalSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))),width,height,videoSize);
int orientation = (int)Resources.Configuration.Orientation;
if(orientation == (int)Android.Content.Res.Orientation.Landscape){
textureView.SetAspectRatio(previewSize.Width,previewSize.Height);
} else {
textureView.SetAspectRatio(previewSize.Height,previewSize.Width);
}
configureTransform(width,height);
mediaRecorder = new MediaRecorder();
manager.OpenCamera(cameraId,stateListener,null);
} catch (CameraAccessException) {
Toast.MakeText (Activity, "Cannot access the camera.", ToastLength.Short).Show ();
Activity.Finish ();
} catch (NullPointerException) {
var dialog = new ErrorDialog ();
dialog.Show (FragmentManager, "dialog");
} catch (InterruptedException) {
throw new RuntimeException ("Interrupted while trying to lock camera opening.");
}
}
public AudioRecorder(string filename)
{
if (filename == "")
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("filename passed in is NULL");
#endif
return;
}
if (System.IO.File.Exists(filename))
System.IO.File.Delete(filename);
recorder = new MediaRecorder();
recorder.SetAudioSource(AudioSource.Mic);
recorder.SetOutputFormat(OutputFormat.ThreeGpp);
recorder.SetAudioEncoder(AudioEncoder.Aac);
tempFilename = System.IO.Path.Combine(wowZapp.LaffOutOut.Singleton.ContentDirectory, "tempfile.3gp");
outputFilename = filename;
#if (DEBUG)
System.Diagnostics.Debug.WriteLine("filename = {0}", filename);
#endif
f = System.IO.File.Create(tempFilename);
recorder.SetOutputFile(tempFilename);
recorder.Prepare();
}
public void OnCompletion(MediaRecorder recorder)
{
f.Close();
if (!failed)
{
recorder.Reset();
recorder.Release();
try
{
System.IO.File.Move(tempFilename, outputFilename);
System.IO.File.Delete(tempFilename);
} catch
{
}
}
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Memory);
ImageButton record = FindViewById<ImageButton> (Resource.Id.vid);
ImageButton btnNormalDialog = FindViewById<ImageButton> (Resource.Id.img);
_imageView = FindViewById<ImageView> (Resource.Id.imgv);
btnNormalDialog.Click += ButtonOnClick;
mToolbar = FindViewById<SupportToolbar>(Resource.Id.toolbar);
mDrawerLayout = FindViewById<DrawerLayout>(Resource.Id.drawer_layout);
mLeftDrawer = FindViewById<ListView>(Resource.Id.left_drawer);
mLeftDrawer.Tag = 0;
SetSupportActionBar(mToolbar);
mLeftDataSet = new List<string>();
mLeftDataSet.Add ("Left Item 1");
mLeftDataSet.Add ("Left Item 2");
mLeftAdapter = new ArrayAdapter<string>(this, Android.Resource.Layout.SimpleListItem1, mLeftDataSet);
mLeftDrawer.Adapter = mLeftAdapter;
mDrawerToggle = new MyActionBarDrawerToggle(
this, //Host Activity
mDrawerLayout, //DrawerLayout
Resource.String.openDrawer, //Opened Message
Resource.String.closeDrawer //Closed Message
);
mDrawerLayout.SetDrawerListener(mDrawerToggle);
SupportActionBar.SetHomeButtonEnabled(true);
SupportActionBar.SetDisplayShowTitleEnabled(true);
mDrawerToggle.SyncState();
if (bundle != null)
{
if (bundle.GetString("DrawerState") == "Opened")
{
SupportActionBar.SetTitle(Resource.String.openDrawer);
}
else
{
SupportActionBar.SetTitle(Resource.String.closeDrawer);
}
}
else
{
//This is the first the time the activity is ran
SupportActionBar.SetTitle(Resource.String.closeDrawer);
}
VideoView video = FindViewById<VideoView> (Resource.Id.vidv);
_button = FindViewById<ImageButton> (Resource.Id.mica);
string path1 = Environment.ExternalStorageDirectory.AbsolutePath + "/test.mp4";
_button.Click += delegate {
if (count == 1) {
_recorder.SetAudioSource (AudioSource.Mic);
_recorder.SetOutputFormat (OutputFormat.ThreeGpp);
_recorder.SetAudioEncoder (AudioEncoder.AmrNb);
_recorder.SetOutputFile (path1);
_recorder.Prepare ();
_recorder.Start ();
Toast toast = Toast.MakeText (this , "Audio Recording", ToastLength.Short);
toast.Show ();
count ++;
} else if (count == 2) {
_recorder.Stop();
_recorder.Release ();
count = 0;
Toast toast = Toast.MakeText (this , "Recording Stopped", ToastLength.Short);
toast.Show ();
}
};
record.Click += delegate {
video.StopPlayback ();
if(c1 == 1)
{
_recorder = new MediaRecorder ();
_recorder.SetVideoSource (VideoSource.Camera);
_recorder.SetAudioSource (AudioSource.Mic);
_recorder.SetOutputFormat (OutputFormat.Default);
_recorder.SetVideoEncoder (VideoEncoder.Default);
_recorder.SetAudioEncoder (AudioEncoder.Default);
_recorder.SetOutputFile (path1);
_recorder.SetPreviewDisplay (video.Holder.Surface);
_recorder.Prepare ();
_recorder.Start ();
c1++;
}
else if(c1 == 2){
if (_recorder != null)
{
_recorder.Stop ();
_recorder.Release ();
c1 = 0;
}
}
};
}
public void OnStop(MediaRecorder recorder)
{
if (!failed)
{
f.Close();
recorder.Stop();
System.IO.File.Move(tempFilename, outputFilename);
System.IO.File.Delete(tempFilename);
}
}
protected override void OnPause()
{
base.OnPause ();
//realease media recorder and player while they are not needed (ie when app paused)
_player.Release ();
_recorder.Release ();
_player.Dispose ();
_recorder.Dispose ();
_player = null;
_recorder = null;
}
private void CloseCamera()
{
try {
cameraOpenCloseLock.Acquire();
if(null != cameraDevice) {
cameraDevice.Close();
cameraDevice = null;
}
if(null != mediaRecorder) {
mediaRecorder.Release();
mediaRecorder = null;
}
} catch (InterruptedException e) {
throw new RuntimeException ("Interrupted while trying to lock camera closing.");
} finally {
cameraOpenCloseLock.Release ();
}
}
private bool prepareVideoRecorder()
{
// BEGIN_INCLUDE (configure_preview)
mCamera = CameraHelper.getDefaultCameraInstance();
// We need to make sure that our preview and recording video size are supported by the
// camera. Query camera to find all the sizes and choose the optimal size given the
// dimensions of our preview surface.
Camera.Parameters parameters = mCamera.GetParameters();
IList <Camera.Size> mSupportedPreviewSizes = parameters.SupportedPreviewSizes;
IList <Camera.Size> mSupportedVideoSizes = parameters.SupportedVideoSizes;
Camera.Size optimalSize = CameraHelper.getOptimalVideoSize(mSupportedVideoSizes,
mSupportedPreviewSizes, mPreview.Width, mPreview.Height);
// Use the same size for recording profile.
CamcorderProfile profile = CamcorderProfile.Get(CamcorderQuality.High);
profile.VideoFrameWidth = optimalSize.Width;
profile.VideoFrameHeight = optimalSize.Height;
// likewise for the camera object itself.
parameters.SetPreviewSize(profile.VideoFrameWidth, profile.VideoFrameHeight);
mCamera.SetParameters(parameters);
try
{
// Requires API level 11+, For backward compatibility use {@link setPreviewDisplay}
// with {@link SurfaceView}
mCamera.SetPreviewTexture(mPreview.SurfaceTexture);
}
catch (IOException e)
{
Log.Error(TAG, "Surface texture is unavailable or unsuitable" + e.Message);
return(false);
}
// END_INCLUDE (configure_preview)
// BEGIN_INCLUDE (configure_media_recorder)
mMediaRecorder = new Android.Media.MediaRecorder();
// Step 1: Unlock and set camera to MediaRecorder
mCamera.Unlock();
mMediaRecorder.SetCamera(mCamera);
// Step 2: Set sources
mMediaRecorder.SetAudioSource(AudioSource.Default);
mMediaRecorder.SetVideoSource(VideoSource.Camera);
// Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
mMediaRecorder.SetProfile(profile);
// Step 4: Set output file
mOutputFile = CameraHelper.getOutputMediaFile(CameraHelper.MEDIA_TYPE_VIDEO);
if (mOutputFile == null)
{
return(false);
}
mMediaRecorder.SetOutputFile(mOutputFile.Path);
// END_INCLUDE (configure_media_recorder)
// Step 5: Prepare configured MediaRecorder
try
{
mMediaRecorder.Prepare();
}
catch (IllegalStateException e)
{
Log.Debug(TAG, "IllegalStateException preparing MediaRecorder: " + e.Message);
releaseMediaRecorder();
return(false);
}
catch (IOException e)
{
Log.Debug(TAG, "IOException preparing MediaRecorder: " + e.Message);
releaseMediaRecorder();
return(false);
}
return(true);
}
