public void StartPreview()
 {
     try
     {
         var numberOfCameras = Camera.NumberOfCameras;
         int? rearFacingCameraId = null;
         // Find the ID of the default camera
         Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
         for (int i = 0; i < numberOfCameras; i++)
         {
             Camera.GetCameraInfo(i, cameraInfo);
             if (cameraInfo.Facing == CameraFacing.Back)
             {
                 rearFacingCameraId = i;
             }
         }
         if (rearFacingCameraId.HasValue)
         {
             camera = Camera.Open(rearFacingCameraId.Value);
             if (cameraPreview != null)
             {
                 cameraPreview.PreviewCamera = camera;
             }
         }
     }
     catch (CameraAccessException ex)
     {
     }
     catch (NullPointerException)
     {
     }
     catch (System.Exception ex)
     {
     }
 }

        protected sealed override void StartPreview()
        {
            _camera = Camera.Open((int)CurrentCamera);
            _camera.SetDisplayOrientation(90);

            var parameters = _camera.GetParameters();
            if (parameters.SupportedFocusModes.Contains(Camera.Parameters.FocusModeContinuousPicture))
            {
                parameters.FocusMode = Camera.Parameters.FocusModeContinuousPicture;
            }

            var optimalSize = GetOptimalPreviewSize(_width, _height);
            if (optimalSize != null)
            {
                parameters.SetPreviewSize(optimalSize.Width, optimalSize.Height);
            }

            _camera.SetParameters(parameters);

            try
            {
                _camera.SetPreviewTexture(_surface);
                _camera.StartPreview();
            }
            catch (Java.IO.IOException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

      /// <summary>
      /// Turn the lamp off
      /// </summary>
      public void TurnOff()
      {
          if (camera == null)
              camera = Camera.Open();

          if (camera == null)
          {
              Debug.WriteLine("Camera failed to initialize");
              return;
          }

          var p = camera.GetParameters();
          var supportedFlashModes = p.SupportedFlashModes;

          if (supportedFlashModes == null)
              supportedFlashModes = new List<string>();

          var flashMode = string.Empty;

          if (supportedFlashModes.Contains(Android.Hardware.Camera.Parameters.FlashModeTorch))
              flashMode = Android.Hardware.Camera.Parameters.FlashModeOff;

          if (!string.IsNullOrEmpty(flashMode))
          {
              p.FlashMode = flashMode;
              camera.SetParameters(p);
          }
      }

		public override View OnCreateView (LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
		{
			// Open an instance of the first camera and retrieve its info.
			camera = GetCameraInstance (CAMERA_ID);
			Camera.CameraInfo cameraInfo = null;

			if (camera != null) {
				// Get camera info only if the camera is available
				cameraInfo = new Camera.CameraInfo ();
				Camera.GetCameraInfo (CAMERA_ID, cameraInfo);
			}

			if (camera == null || cameraInfo == null) {
				Toast.MakeText (Activity, "Camera is not available.", ToastLength.Short).Show ();
				return inflater.Inflate (Resource.Layout.fragment_camera_unavailable, null);
			}

			View root = inflater.Inflate (Resource.Layout.fragment_camera, null);

			// Get the rotation of the screen to adjust the preview image accordingly.
			SurfaceOrientation displayRotation = Activity.WindowManager.DefaultDisplay.Rotation;

			// Create the Preview view and set it as the content of this Activity.
			cameraPreview = new CameraPreview (Activity, camera, cameraInfo, displayRotation);
			var preview =  root.FindViewById <FrameLayout> (Resource.Id.camera_preview);
			preview.AddView (cameraPreview);

			return root;
		}

        public void OnSurfaceTextureAvailable (Android.Graphics.SurfaceTexture surface, int width, int height)
        {
			if (Camera.NumberOfCameras == 0) {
				Toast.MakeText (this, Resource.String.no_camera, ToastLength.Long).Show ();
				return;
			}
			_camera = Camera.Open();
			if (_camera == null)
				_camera = Camera.Open (0);
            
            var previewSize = _camera.GetParameters ().PreviewSize;
            _textureView.LayoutParameters = 
                new FrameLayout.LayoutParams (previewSize.Width, previewSize.Height, GravityFlags.Center);
            
            try {
                _camera.SetPreviewTexture (surface);
                _camera.StartPreview ();
            } catch (Java.IO.IOException ex) {
                Console.WriteLine (ex.Message);
            }
            
            // this is the sort of thing TextureView enables
            _textureView.Rotation = 45.0f;
            _textureView.Alpha = 0.5f;
        }

        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);

			SetContentView(Resource.Layout.ScannerView);

            var frameLayout = (FrameLayout)FindViewById(Resource.Id.cameraPreview);

            camera = GetCameraInstance();

            if (camera == null)
            {
                Complete(new Intent());
                return;
            }

            previewCb = new PreviewCallback();

            previewCb.ScanComplete += PreviewCb_ScanComplete;

            camPreview = new CameraPreview(this, camera, previewCb);

            frameLayout.AddView(camPreview);
                
        }

 public override void OnPause()
 {
     base.OnPause();
     if (mCamera != null) {
         mCamera.Release();
         mCamera = null;
     }
 }

		protected void StartCamera() {
			if (_Camera == null) {
				_Camera = Camera.Open();
				_CameraSupportedFlashModes = _CameraSupportedFlashModes ?? _Camera.GetParameters().SupportedFlashModes;
				if (_CameraSupportedFlashModes == null || !_CameraSupportedFlashModes.Contains(FlashlightOnMode) || !_CameraSupportedFlashModes.Contains(FlashlightOffMode)) {
					StopCamera();
				}
			}
		}

		protected override void OnResume ()
		{
			base.OnResume ();

			// Open the default i.e. the first rear facing camera.
			mCamera = Camera.Open ();
			cameraCurrentlyLocked = defaultCameraId;
			mPreview.PreviewCamera = mCamera;
		}

 protected string GetCameraFlashMode(Camera.Parameters cameraParameters = null)
 {
     string mode = null;
     if (_Camera != null) {
         if (cameraParameters == null) {
             cameraParameters = _Camera.GetParameters();
         }
         mode = cameraParameters.FlashMode;
     }
     return mode;
 }

		protected override void OnPause ()
		{
			base.OnPause ();

			// Because the Camera object is a shared resource, it's very
			// important to release it when the activity is paused.
			if (mCamera != null) {
				mPreview.PreviewCamera = null;
				mCamera.Release ();
				mCamera = null;
			}
		}

      public CameraPreview(Context context, Camera.IPreviewCallback previewCallback, bool cameraPreviewCallbackWithBuffer)
         : base(context)
      {
         _cameraPreviewCallbackWithBuffer = cameraPreviewCallbackWithBuffer;

         // Install a SurfaceHolder.Callback so we get notified when the
         // underlying surface is created and destroyed.
         _surfaceHolder = Holder;
         _surfaceHolder.AddCallback(this);

         _cameraPreviewCallback = previewCallback;
      }

 public void CleanUpCamera()
 {
     if (camera != null)
     {
         camera.StopPreview();
         if (cameraPreview != null)
         {
             cameraPreview.PreviewCamera = null;
         }
         camera.Release();
         camera = null;
     }
 }

	    public void SurfaceCreated (ISurfaceHolder holder)
		{
			try 
			{
				var version = Android.OS.Build.VERSION.SdkInt;

				if (version >= BuildVersionCodes.Gingerbread)
				{
					var numCameras = Android.Hardware.Camera.NumberOfCameras;
					var camInfo = new Android.Hardware.Camera.CameraInfo();
					var found = false;
					
					for (int i = 0; i < numCameras; i++)
					{
						Android.Hardware.Camera.GetCameraInfo(i, camInfo);
						if (camInfo.Facing == CameraFacing.Back)
						{
							camera = Android.Hardware.Camera.Open(i);
							found = true;
							break;
						}
					}
					
					if (!found)
					{
						Android.Util.Log.Debug("ZXing.Net.Mobile", "Finding rear camera failed, opening camera 0...");
						camera = Android.Hardware.Camera.Open(0);
					}
				}
				else
				{
					camera = Android.Hardware.Camera.Open();
				}
				if (camera == null)
					Android.Util.Log.Debug("ZXing.Net.Mobile", "Camera is null :(");
				
				
				//camera = Android.Hardware.Camera.Open ();
				camera.SetPreviewDisplay (holder);
				//camera.SetPreviewCallback (this);
				camera.SetOneShotPreviewCallback(this);

				
			} catch (Exception ex) {
				ShutdownCamera ();
				
				// TODO: log or otherwise handle this exception
				Console.WriteLine("Setup Error: " + ex);
				//throw;
			}
		}

 public void OnSurfaceTextureAvailable (Android.Graphics.SurfaceTexture surface, int w, int h)
 {
     _camera = Camera.Open ();
     
     _textureView.LayoutParameters = new FrameLayout.LayoutParams (w, h);
     
     try {
         _camera.SetPreviewTexture (surface);
         _camera.StartPreview ();
         
     } catch (Java.IO.IOException ex) {
         Console.WriteLine (ex.Message);
     }
 }

			public void SurfaceCreated (ISurfaceHolder holder)
			{
				try {
					camera = Camera.Open ();
					camera.SetPreviewDisplay (holder);
					camera.SetPreviewCallback (this);

				} catch (Exception e) {
					ShutdownCamera ();

					// TODO: log or otherwise handle this exception

					throw;
				}
			}

        public bool Liga()
        {
            if (TemFlash)
            {
                camera = Camera.Open();

                var parametros = camera.GetParameters();
                parametros.FlashMode = Camera.Parameters.FlashModeTorch;

                camera.SetParameters(parametros);
                camera.StartPreview();

                return true;
            }
            return false;
        }

        public CameraPreview(Context context, Camera camera,Camera.IPreviewCallback previewCallback) : base(context)
        {
            this.camera = camera;
            this.previewCallback = previewCallback;

            var parameters = this.camera.GetParameters();
            foreach (var p in from f in parameters.SupportedFocusModes where f == Camera.Parameters.FocusModeContinuousPicture select this.camera.GetParameters())
            {
                p.FocusMode = Camera.Parameters.FocusModeContinuousPicture;
                this.camera.SetParameters(p);
            }

            surfaceHolder = base.Holder;
            surfaceHolder.AddCallback(this);

        }

		public override void Prepare(){
			
			if (camera == null) {
				camera = Camera.Open();
			}
			
			// We reconnect to camera to change flash state if needed
			camera.Reconnect();
			Camera.Parameters parameters = camera.GetParameters();
			parameters.FlashMode = flashState?Camera.Parameters.FlashModeTorch:Camera.Parameters.FlashModeOff;
			camera.SetParameters(parameters);
			camera.SetDisplayOrientation(quality.Orientation);
			camera.StopPreview();
			camera.Unlock();
			base.SetCamera(camera);

			base.SetVideoSource(Android.Media.VideoSource.Camera);
			base.SetOutputFormat(Android.Media.OutputFormat.ThreeGpp);
			base.SetMaxDuration(0);
			base.SetMaxFileSize(int.MaxValue);

			base.SetVideoEncoder(videoEncoder);
			base.SetVideoSize(quality.ResX,quality.ResY);
			base.SetVideoFrameRate(quality.FrameRate);
			base.SetVideoEncodingBitRate(quality.BitRate);


			//SetAudioSource(Android.Media.AudioSource.Mic);
			/*SetVideoSource(Android.Media.VideoSource.Camera);
			
			SetOutputFormat(Android.Media.OutputFormat.ThreeGpp);
			//SetAudioEncoder(Android.Media.AudioEncoder.AmrNb);
			SetVideoEncoder(Android.Media.VideoEncoder.H263);
			SetVideoSize(640,480);
			SetVideoFrameRate(15);
			SetVideoEncodingBitRate(500000);*/

			base.SetPreviewDisplay(surfaceHolder.Surface);
			base.Prepare();
			// Reset flash state to ensure that default behavior is to turn it off
			flashState = false;
			
			// Quality has been updated
			qualityHasChanged = false;
			
		}

		public CameraPreview (Context context, Camera camera, Camera.CameraInfo cameraInfo, 
			SurfaceOrientation displayOrientation) :
			base (context)
		{
			// Do not initialize if no camera has been set
			if (camera == null || cameraInfo == null)
				return;
			
			this.camera = camera;
			this.cameraInfo = cameraInfo;
			this.displayOrientation = displayOrientation;

			// Install a SurfaceHolder.Callback so we get notified when the
			// underlying surface is created and destroyed.
			holder = Holder;
			holder.AddCallback (this);
		}