content: package me.hawkshaw.test;
  
  import android.Manifest;
  import android.content.Context;
  import android.content.pm.PackageManager;
  import android.graphics.ImageFormat;
  import android.hardware.camera2.CameraAccessException;
  import android.hardware.camera2.CameraCaptureSession;
  import android.hardware.camera2.CameraCharacteristics;
  import android.hardware.camera2.CameraDevice;
  import android.hardware.camera2.CameraManager;
  import android.hardware.camera2.CaptureRequest;
  import android.hardware.camera2.TotalCaptureResult;
  import android.hardware.camera2.params.StreamConfigurationMap;
  import android.media.Image;
  import android.media.ImageReader;
  import android.os.Environment;
  import android.os.Handler;
  import android.os.HandlerThread;
  import android.support.annotation.NonNull;
  import android.support.v4.content.ContextCompat;
  import android.util.Log;
  import android.util.Size;
  import android.widget.Toast;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.nio.ByteBuffer;
  import java.text.SimpleDateFormat;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Date;
  import java.util.concurrent.Semaphore;
  import java.util.concurrent.TimeUnit;
  
  /**
   * Created by rajesh kumar sahanee on 2/9/17.
   */
  
  
  public class Whatever {
  
      private Context context;
  
      private static final String TAG = "CCV2WithoutPreview";
  
      private String mCameraId;
      private CameraCaptureSession mCaptureSession;
      private CameraDevice mCameraDevice;
  
      private HandlerThread backgroundThread;
      private Handler backgroundHandler;
      private ImageReader imageReader;
      private File file;
  
      private Semaphore mCameraOpenCloseLock = new Semaphore(1);
  
  
      public Whatever(Context context) {
          this.context = context;
      }
  
      public void openCamera() {
          if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
              return;
          }
          setUpCameraOutputs();
          CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
          try {
              if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
                  throw new RuntimeException("Time out waiting to lock camera opening.");
              }
              startBackgroundThread();
              if (manager != null)
                  manager.openCamera(mCameraId, mStateCallback, backgroundHandler);
          } catch (CameraAccessException e) {
              e.printStackTrace();
          } catch (InterruptedException e) {
              throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
          }
      }
  
      private void setUpCameraOutputs() {
          CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
          try {
              for (String cameraId : manager.getCameraIdList()) {
                  CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
  
                  // We don't use a front facing camera in this sample.
                  Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
                  if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
                      continue;
                  }
  
                  StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                  if (map == null) {
                      continue;
                  }
  
                  // For still image captures, we use the largest available size.
                  Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
                  imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG,2);
                  imageReader.setOnImageAvailableListener(mOnImageAvailableListener, backgroundHandler);
  
                  mCameraId = cameraId;
                  return;
              }
          } catch (CameraAccessException | NullPointerException e) {
              e.printStackTrace();
          }
      }
  
      private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
  
          @Override
          public void onOpened(@NonNull CameraDevice cameraDevice) {
              // This method is called when the camera is opened.  We start camera preview here.
              mCameraOpenCloseLock.release();
              mCameraDevice = cameraDevice;
              createCameraCaptureSession();
          }
  
          @Override
          public void onDisconnected(@NonNull CameraDevice cameraDevice) {
              mCameraOpenCloseLock.release();
              cameraDevice.close();
              mCameraDevice = null;
          }
  
          @Override
          public void onError(@NonNull CameraDevice cameraDevice, int error) {
              mCameraOpenCloseLock.release();
              cameraDevice.close();
              mCameraDevice = null;
          }
  
      };
  
      private final ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() {
  
          @Override
          public void onImageAvailable(ImageReader reader) {
              Log.d(TAG, "ImageAvailable");
              backgroundHandler.post(new ImageSaver(reader.acquireNextImage(), file));
          }
  
      };
  
      public void closeCamera() {
          try {
              mCameraOpenCloseLock.acquire();
              if (null != mCaptureSession) {
                  mCaptureSession.close();
                  mCaptureSession = null;
              }
              if (null != mCameraDevice) {
                  mCameraDevice.close();
                  mCameraDevice = null;
              }
              if (null != imageReader) {
                  imageReader.close();
                  imageReader = null;
              }
          } catch (InterruptedException e) {
              throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
          } finally {
              mCameraOpenCloseLock.release();
              stopBackgroundThread();
          }
      }
  
      private void startBackgroundThread() {
          backgroundThread = new HandlerThread("CameraBackground");
          backgroundThread.start();
          backgroundHandler = new Handler(backgroundThread.getLooper());
      }
  
      private void stopBackgroundThread() {
          backgroundThread.quitSafely();
          try {
              backgroundThread.join();
              backgroundThread = null;
              backgroundHandler = null;
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  
      private void createCameraCaptureSession() {
          try {
  
              // Here, we create a CameraCaptureSession for camera preview.
              mCameraDevice.createCaptureSession(Arrays.asList(imageReader.getSurface()),
                      new CameraCaptureSession.StateCallback() {
  
                          @Override
                          public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                              // The camera is already closed
                              if (null == mCameraDevice) {
                                  return;
                              }
  
                              // When the session is ready, we start displaying the preview.
                              mCaptureSession = cameraCaptureSession;
                          }
  
                          @Override
                          public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
                              Log.d(TAG, "Configuration Failed");
                          }
                      }, null
              );
          } catch (CameraAccessException e) {
              e.printStackTrace();
          }
      }
  
      public void takePicture() {
          file = getOutputMediaFile();
          try {
              if (null == mCameraDevice) {
                  return;
              }
              // This is the CaptureRequest.Builder that we use to take a picture.
              final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
              captureBuilder.addTarget(imageReader.getSurface());
  
              // Use the same AE and AF modes as the preview.
              captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  
              CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {
  
                  @Override
                  public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                      Log.d(TAG, file.toString());
                  }
              };
  
              mCaptureSession.stopRepeating();
              mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
          } catch (CameraAccessException e) {
              e.printStackTrace();
          }
          Toast.makeText(context, file.getAbsolutePath(), Toast.LENGTH_SHORT).show();
      }
  
      private static class ImageSaver implements Runnable {
  
          /**
           * The JPEG image
           */
          private final Image mImage;
          /**
           * The file we save the image into.
           */
          private final File mFile;
  
          public ImageSaver(Image image, File file) {
              mImage = image;
              mFile = file;
          }
  
          @Override
          public void run() {
              ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
              byte[] bytes = new byte[buffer.remaining()];
              buffer.get(bytes);
              FileOutputStream output = null;
              try {
                  output = new FileOutputStream(mFile);
                  output.write(bytes);
              } catch (IOException e) {
                  e.printStackTrace();
              } finally {
                  mImage.close();
                  if (null != output) {
                      try {
                          output.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
  
      }
  
      static class CompareSizesByArea implements Comparator<Size> {
  
          @Override
          public int compare(Size lhs, Size rhs) {
              // We cast here to ensure the multiplications won't overflow
              return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
          }
  
      }
  
      private File getOutputMediaFile() {
          // To be safe, you should check that the SDCard is mounted
          // using Environment.getExternalStorageState() before doing this.
  
          File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "Camera2Test");
  
          // This location works best if you want the created images to be shared
          // between applications and persist after your app has been uninstalled.
  
          // Create the storage directory if it does not exist
          if (!mediaStorageDir.exists()) {
              if (!mediaStorageDir.mkdirs()) {
                  return null;
              }
          }
  
          // Create a media file name
          String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
  
          File mediaFile;
          mediaFile = new File(mediaStorageDir.getPath() + File.separator + "IMG_" + timeStamp + ".jpg");
  
          return mediaFile;
      }
  
  }