title: Android camera autofocus
body: <p>I have a camera application in android.It's a custom camera. I want to use auto focus. But I can not do that. How to set auto focus and where I have to call. I tried a lot, but I can not able to fix it. Please help me.</p>
  
  <p>Here is my custom camera activity:</p>
  
  <pre><code>public class CustomCameraActivity extends Activity implements
      SurfaceHolder.Callback {
  
  Camera camera;
  SurfaceView surfaceView;
  SurfaceHolder surfaceHolder;
  boolean previewing = false;
  LayoutInflater controlInflater = null;
  Context context;
   Button btn1;
   Button btn2;
  ImageView imageView;
  private Sensor mOrientaion1;
  int cameraId = 0;
  public final String TAG = "CustomCamera";
  private OrientationEventListener orientationListener = null;
  
  private SensorManager sensorManager;
  float[] mGravs = new float[3];
  float[] mGeoMags = new float[3];
  float[] mRotationM = new float[16];
  float[] mInclinationM = new float[16];
  float[] mOrientation = new float[3];
  float[] mOldOreintation = new float[3];
  String[] mAccelerometer = new String[3];
  String[] mMagnetic = new String[3];
  String[] mRotation = new String[16];
  String[] mInclination = new String[16];
  String[] mOrientationString = new String[3];
  String[] mOldOreintationString = new String[3];
  
  @Override
  public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
  
      requestWindowFeature(Window.FEATURE_NO_TITLE);
      getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
              WindowManager.LayoutParams.FLAG_FULLSCREEN);
  
      setContentView(R.layout.main);
      context = this;
  
      sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
      mOrientaion1 = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);
  
      orientationListener = new OrientationEventListener(this) {
          public void onOrientationChanged(int orientation) {
              setCameraDisplayOrientation(CustomCameraActivity.this, cameraId, camera);
          }
      };
  
      // setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  
      //imageView = (ImageView) findViewById(R.id.imgError);
  
      getWindow().setFormat(PixelFormat.UNKNOWN);
      surfaceView = (SurfaceView) findViewById(R.id.camerapreview);
      surfaceHolder = surfaceView.getHolder();
      surfaceHolder.addCallback(this);
      surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
  
      controlInflater = LayoutInflater.from(getBaseContext());
      View viewControl = controlInflater.inflate(R.layout.custom, null);
      LayoutParams layoutParamsControl = new LayoutParams(
              LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
  
      btn1 = (Button) viewControl.findViewById(R.id.Button01);
      btn2 = (Button) viewControl.findViewById(R.id.Button02);
  
      btn1.setOnClickListener(new OnClickListener() {
  
          @Override
          public void onClick(View arg0) {
              // Toast.makeText(context, "1111111111111111111111111",
              // Toast.LENGTH_SHORT).show();
  
              camera.takePicture(null, null, mPicture);
              btn1.setVisibility(View.INVISIBLE);
              btn2.setVisibility(View.INVISIBLE);
              Constant.rotationValueForCamera = Constant.rotationValue;
          }
      });
  
      btn2.setOnClickListener(new OnClickListener() {
  
          @Override
          public void onClick(View arg0) {
              // Toast.makeText(context, "22222222222222222222222222",
              // Toast.LENGTH_SHORT).show();
              Log.e("0 imagePickerStatus", Constant.imagePickerStatus + "");
  
              Constant.imagePickerStatus = 0;
  
              Log.e("0 imagePickerStatus", Constant.imagePickerStatus + "");
  
              finish();
          }
      });
  
      this.addContentView(viewControl, layoutParamsControl);
  
      int ot = getResources().getConfiguration().orientation;
  
      if (Configuration.ORIENTATION_LANDSCAPE == ot) {
          //imageView.setVisibility(View.GONE);
          Log.e("ori1111", "land");
      } else {
          //imageView.setVisibility(View.VISIBLE);
          Log.e("ori111", "port");
      }
  }
  
  
  
  public String getPollDeviceAttitude() {
  
      return Constant.rotationValueForCamera;
  }
  
  private SensorEventListener sensorEventListener = new SensorEventListener() {
  
      public void onAccuracyChanged(Sensor sensor, int accuracy) {
  
      }
  
      @Override
      public void onSensorChanged(SensorEvent event) {
          if(event.sensor.getType() == Sensor.TYPE_ACCELEROMETER)
              mGravs = event.values.clone();// Fill gravityMatrix with accelerometer values
          else if(event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
              mGeoMags = event.values.clone();// Fill geomagneticMatrix with magnetic-field sensor values
          if(mGravs != null &amp;&amp; mGeoMags != null){
              mRotationM = new float[16];
              mInclinationM = new float[16];
  
              SensorManager.getRotationMatrix(mRotationM, mInclinationM, mGravs, mGeoMags);// Retrieve RMatrix, necessary for the getOrientation method
              SensorManager.getOrientation(mRotationM, mOrientation);// Get the current orientation of the device
  
              float r2d = 180f/(float)Math.PI;
  
              DecimalFormat format = new DecimalFormat("#.##");
  
              float[] ang = { 0.0f, mOrientation[1]*r2d, mOrientation[2]*r2d };
  
              if ( ang[2] &lt; 0.0f ) 
              {
                  ang[2] = ang[2] + 90.0f;
              }
              else
              {
                  ang[2] = 90 - ang[2];
                  ang[1] = -ang[1];
              }
  
              String x = format.format(ang[2]); //format.format(mOrientation[0]*r2d);
              String y = format.format(ang[0]);
              String z = format.format(ang[1]);
  
              Constant.rotationValue =
                      x + " " +
                      y + " " +
                      z;
          }
      }
  
  };
  
  protected void onPause() {
      super.onPause();
      sensorManager.unregisterListener(sensorEventListener);
      orientationListener.disable();
  
  }
  
  @Override
  public void onResume() {
      super.onResume();
      btn1.setVisibility(View.VISIBLE);
      btn2.setVisibility(View.VISIBLE);
      sensorManager.registerListener(sensorEventListener,
              sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
              SensorManager.SENSOR_DELAY_NORMAL);
      sensorManager.registerListener(sensorEventListener,
              sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
              SensorManager.SENSOR_DELAY_NORMAL);
      sensorManager.registerListener(sensorEventListener,
              sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION),
              SensorManager.SENSOR_DELAY_NORMAL);
  
      if (Constant.isCapturedOk) {
          Constant.isCapturedOk = false;
  
          finish();
      }
  
  }
  
  PictureCallback mPicture = new PictureCallback() {
      @Override
      public void onPictureTaken(byte[] data, Camera camera) {
          Constant.imageData1 = data;
          Log.e("Camrera", "22222222222222222");
          BitmapFactory.Options bfo = new BitmapFactory.Options();
          bfo.inDither = false;
          // bfo.inJustDecodeBounds = true;
          bfo.inPurgeable = true;
          bfo.inTempStorage = new byte[16 * 1024];
  
          Intent intent = new Intent(context, PreviewActivity.class);
          // intent.putExtra("data", data);
          Bitmap bitmapPicture = BitmapFactory.decodeByteArray(data, 0,
                  data.length, bfo);
          Matrix matrix = new Matrix();
          if (Constant.result == 0) {
              matrix.postRotate(90);
          }
          if (Constant.result == 90) {
              matrix.postRotate(0);
          }
          if (Constant.result == 180) {
              matrix.postRotate(270);
          }
          if (Constant.result == 270) {
              matrix.postRotate(180);
          }
          int height = bitmapPicture.getHeight();
          int width = bitmapPicture.getWidth();
          //Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmapPicture,
                  //height, width, true);
          Bitmap rotatedBitmap = Bitmap.createBitmap(bitmapPicture, 0, 0,
                  bitmapPicture.getWidth(), bitmapPicture.getHeight(), matrix,
                  true);
          ByteArrayOutputStream blob = new ByteArrayOutputStream();
          Log.e("Camrera1", "22222222222222222");
          rotatedBitmap.compress(CompressFormat.JPEG,
                  50 /* ignored for PNG */, blob);
          byte[] bitmapdata = blob.toByteArray();
          Constant.imageData = bitmapdata;
          Log.e("Camrera2", "22222222222222222");
          startActivity(intent);
          overridePendingTransition(R.anim.slide_right, R.anim.slide_left);
      }
  };
  
  
  @Override
  public void surfaceChanged(SurfaceHolder holder, int format, int width,
          int height) {
      Camera.Parameters parameters = camera.getParameters();
      Camera.Size size = getBestPreviewSize(width, height);    
      parameters.setPreviewSize(size.width, size.height); // preview size
      camera.setParameters(parameters);
      if (previewing) {
          camera.stopPreview();
          previewing = false;
      }
  
      if (camera != null) {
          try {
              camera.setPreviewDisplay(holder);
              camera.startPreview();
              setCameraDisplayOrientation(this, 1, camera);
              previewing = true;
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  
  
  public static void setCameraDisplayOrientation(Activity activity,
          int cameraId, android.hardware.Camera camera) {
      android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
      android.hardware.Camera.getCameraInfo(cameraId, info);
  
      int rotation = activity.getWindowManager().getDefaultDisplay()
              .getRotation();
      int degrees = 0;
      switch (rotation) {
      case Surface.ROTATION_0:
          degrees = 0;
          Constant.result = 0;
          break;
      case Surface.ROTATION_90:
          degrees = 90;
          Constant.result = 90;
          break;
      case Surface.ROTATION_180:
          degrees = 180;
          Constant.result = 180;
          break;
      case Surface.ROTATION_270:
          degrees = 270;
          Constant.result = 270;
          break;
      }
  
      int result;
      if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
          result = (info.orientation + degrees) % 360;
          result = (360 - result) % 360; // compensate the mirror
      } else { // back-facing
          result = (info.orientation - degrees + 360) % 360;
      }
      if(camera != null)
      camera.setDisplayOrientation(result);
  }
  
  
  
  
  
  
  private Camera.Size getBestPreviewSize(int width, int height)
  {
  
              // Get For Photo Size
      Camera.Parameters camparams = camera.getParameters();
  
      // Find the Largest Possible Preview Sizes
      List&lt;Size&gt; sizes = camparams.getSupportedPreviewSizes();
      Camera.Size result=null;
      for (Size s : sizes) {
  
          if (s.width &lt;= width &amp;&amp; s.height &lt;= height) {
                     if (result == null) {
                      result = s;
                     } else {
                      int resultArea=result.width*result.height; 
                      int newArea=s.width*s.height;
  
                      if (newArea&gt;resultArea) {
                                          result=s;
                      }
                         } // end else (result=null)
              } // end if (width&lt;width&amp;&amp;height&lt;height)
      } // end for
  
          return result;
  
  } // end function
  
  @Override
  public void surfaceCreated(SurfaceHolder holder) {
      orientationListener.enable();
      camera = Camera.open();
  }
  
  @Override
  public void surfaceDestroyed(SurfaceHolder holder) {
      orientationListener.disable();
      camera.stopPreview();
      camera.release();
      camera = null;
      previewing = false;
  }
  
  @Override
  protected void onStop() {
      super.onStop();
  
      Log.e("Tab", "Stoping");
  }
  
  @Override
  public boolean onKeyDown(int keyCode, KeyEvent event) {
  
      if (keyCode == KeyEvent.KEYCODE_BACK) {
  
          return true;
  
      }
      return super.onKeyDown(keyCode, event);
  
  }
  }
  </code></pre>