VideoRecording

import java.io.IOException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import android.hardware.Camera;
import android.hardware.Camera.Size;
import android.media.CamcorderProfile;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.SeekBar;
import android.widget.Toast;
import android.widget.ToggleButton;

@SuppressWarnings("unused")
public class VideoRecording extends Activity implements SurfaceHolder.Callback {

	private SurfaceHolder surfaceHolder;
	private SurfaceView surfaceView;
	public MediaRecorder mediaRecorder;
	private Camera mCamera;
	private ToggleButton mToggleButton;
	private SeekBar seekBar;
	private Timer mTimer;
	private TimerTask mTimerTask;
	public final int mPreferableWidth = 1280;
	public final int mPreferableHeight = 720;
	private Timer mTimerSeekBar;
	private TimerTask mTimerTaskSeekBar;
	private String mImagePath = "";

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.camera_surface);
		try {
			// Open Camera
			mCamera = Camera.open();

			surfaceView = (SurfaceView) findViewById(R.id.surface_camera);
			mToggleButton = (ToggleButton) findViewById(R.id.togglebutton);

			surfaceHolder = surfaceView.getHolder();
			surfaceHolder.addCallback(this);

			mImagePath = getIntent().getStringExtra("mImageName");

			mToggleButton.setOnCheckedChangeListener(new OnCheckedChangeListener() {

				@Override
				public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
					if (isChecked) {
						try {
							startRecording();
							mTimer.schedule(mTimerTask, 10000);
							mTimerSeekBar.schedule(mTimerTaskSeekBar, 1000, 1000);
						} catch (Exception e) {
							String message = e.getMessage();
							Log.i(null, "Problem Start" + message);
							mediaRecorder.release();
							Toast.makeText(getApplicationContext(), "Error to Connect Camera", Toast.LENGTH_SHORT).show();
							finish();
						}
					} else {
						stopRecording();
					}
				}
			});

			mTimer = new Timer();
			mTimerTask = new TimerTask() {
				@Override
				public void run() {
					stopRecording();
				}
			};

			seekBar = (SeekBar) findViewById(R.id.seekBar);
			seekBar.setMax(10);
			seekBar.setEnabled(false);

			mTimerSeekBar = new Timer();
			mTimerTaskSeekBar = new TimerTask() {
				@Override
				public void run() {
					if (seekBar.getProgress() < 10) {
						runOnUiThread(new Runnable() {
							@Override
							public void run() {
								seekBar.setProgress(seekBar.getProgress() + 1);
							}
						});
					}
				}
			};
		} catch (Exception e) {
			e.printStackTrace();
			Toast.makeText(getApplicationContext(), "Error to Connect Camera", Toast.LENGTH_SHORT).show();
			finish();
		}

	}

	public void stopRecording() {
		if (mediaRecorder != null) {
			mediaRecorder.stop();
			mediaRecorder.release();
			mediaRecorder = null;
			mCamera.release();
			mCamera = null;
			mTimerSeekBar.cancel();
			// Intent mIntent = new Intent(VideoRecording.this, ShareActivity.class);
			// mIntent.putExtra("mFileType", "video");
			// mIntent.putExtra("mImagePath", mOutputFilePath);
			// startActivity(mIntent);
			// finish();
			setResult(RESULT_OK);
			finish();
		}
	}

	protected void startRecording() throws IOException {
		try {
			mediaRecorder = new MediaRecorder(); // Works well
			mCamera.unlock();

			mediaRecorder.setCamera(mCamera);

			mediaRecorder.setPreviewDisplay(surfaceHolder.getSurface());
			mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
			mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
			mediaRecorder.setPreviewDisplay(surfaceHolder.getSurface());
			mediaRecorder.setMaxDuration(10000); // Set max duration 10 sec.
			mediaRecorder.setMaxFileSize(10000000); // Set max file size 10M
			CamcorderProfile camcorderProfile = CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH);
			mediaRecorder.setProfile(camcorderProfile);

			mediaRecorder.setOutputFile(mImagePath);

			mediaRecorder.prepare();
			mediaRecorder.start();
		} catch (Exception e) {
			e.printStackTrace();
			throw new IOException(e.getMessage());
		}
	}

	private void releaseMediaRecorder() {
		if (mediaRecorder != null) {
			mediaRecorder.stop();
			mediaRecorder.reset(); // clear recorder configuration
			mediaRecorder.release(); // release the recorder object
			mediaRecorder = null;
			// mCamera.lock(); // lock camera for later use
		}
	}

	private void releaseCamera() {
		if (mCamera != null) {
			mCamera.release(); // release the camera for other applications
			mCamera = null;
		}
	}

	@Override
	public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
		if (mCamera != null) {
			try {
				Camera.Parameters parameters = mCamera.getParameters();
				List<Size> sizes = parameters.getSupportedPreviewSizes();
				Size mOptimalSize = getOptimalSize(sizes, width, height);
				parameters.setPreviewSize(mPreferableWidth, mPreferableHeight);
				mCamera.setParameters(parameters);
				mCamera.startPreview();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Calculate the optimal size of camera preview
	 * 
	 * @param sizes
	 * @param w
	 * @param h
	 * @return
	 */
	private Size getOptimalSize(List<Size> sizes, int w, int h) {

		final double ASPECT_TOLERANCE = 0.2;
		double targetRatio = (double) w / h;

		if (sizes == null)
			return null;

		Size optimalSize = null;
		double minDiff = Double.MAX_VALUE;
		int targetHeight = h;

		// Try to find an size match aspect ratio and size
		for (Size size : sizes) {
			// Log.d("CameraActivity", "Checking size " + size.width + "w " + size.height + "h");
			double ratio = (double) size.width / size.height;
			if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)
				continue;
			if (Math.abs(size.height - targetHeight) < minDiff) {
				optimalSize = size;
				minDiff = Math.abs(size.height - targetHeight);
			}
		}

		// Cannot find the one match the aspect ratio, ignore the requirement
		if (optimalSize == null) {
			minDiff = Double.MAX_VALUE;
			for (Size size : sizes) {
				if (Math.abs(size.height - targetHeight) < minDiff) {
					optimalSize = size;
					minDiff = Math.abs(size.height - targetHeight);
				}
			}
		}

		return optimalSize;
	}

	@Override
	public void surfaceCreated(SurfaceHolder holder) {
		if (mCamera != null) {
			try {
				mCamera.setPreviewDisplay(holder);
				mCamera.setDisplayOrientation(90);
				mCamera.startPreview();
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			Toast.makeText(getApplicationContext(), "Camera not available!", Toast.LENGTH_LONG).show();
			finish();
		}
	}

	@Override
	public void surfaceDestroyed(SurfaceHolder holder) {
		if (mCamera != null) {
			releaseMediaRecorder();
			mCamera.stopPreview();
			releaseCamera();
		}
	}

	@Override
	protected void onPause() {
		super.onPause();
	}

	@Override
	public void onBackPressed() {
		super.onBackPressed();
		mTimer.cancel();
		mTimerSeekBar.cancel();
	}

}