media/Camera2Basic/Camera2BasicSample/src/main/java/com/example/android/camera2basic/Camera2BasicFragment.java - platform/developers/samples/android - Git at Google

 /*
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.example.android.camera2basic;

 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.Dialog;
 import android.app.DialogFragment;
 import android.app.Fragment;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.res.Configuration;
 import android.graphics.ImageFormat;
 import android.graphics.Matrix;
 import android.graphics.RectF;
 import android.graphics.SurfaceTexture;
 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.CameraMetadata;
 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.Bundle;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.util.Log;
 import android.util.Size;
 import android.util.SparseIntArray;
 import android.view.LayoutInflater;
 import android.view.Surface;
 import android.view.TextureView;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.Toast;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;

 public class Camera2BasicFragment extends Fragment implements View.OnClickListener {

     /**
      * Conversion from screen rotation to JPEG orientation.
      */
     private static final SparseIntArray ORIENTATIONS = new SparseIntArray();

     static {
         ORIENTATIONS.append(Surface.ROTATION_0, 90);
         ORIENTATIONS.append(Surface.ROTATION_90, 0);
         ORIENTATIONS.append(Surface.ROTATION_180, 270);
         ORIENTATIONS.append(Surface.ROTATION_270, 180);
     }

     private static final String TAG = "Camera2BasicFragment";

     /**
      * {@link TextureView.SurfaceTextureListener} handles several lifecycle events on a
      * {@link TextureView}.
      */
     private final TextureView.SurfaceTextureListener mSurfaceTextureListener
             = new TextureView.SurfaceTextureListener() {

         @Override
         public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) {
             openCamera(width, height);
         }

         @Override
         public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) {
             configureTransform(width, height);
         }

         @Override
         public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
             return true;
         }

         @Override
         public void onSurfaceTextureUpdated(SurfaceTexture texture) {
         }

     };

     /**
      * ID of the current {@link CameraDevice}.
      */
     private String mCameraId;

     /**
      * An {@link AutoFitTextureView} for camera preview.
      */
     private AutoFitTextureView mTextureView;

     /**
      * A {@link CameraCaptureSession } for camera preview.
      */

     private CameraCaptureSession mCaptureSession;
     /**
      * A reference to the opened {@link CameraDevice}.
      */

     private CameraDevice mCameraDevice;
     /**
      * The {@link android.util.Size} of camera preview.
      */

     private Size mPreviewSize;

     /**
      * {@link CameraDevice.StateListener} is called when {@link CameraDevice} changes its state.
      */
     private final CameraDevice.StateListener mStateListener = new CameraDevice.StateListener() {

         @Override
         public void onOpened(CameraDevice cameraDevice) {
             // This method is called when the camera is opened.  We start camera preview here.
             mCameraDevice = cameraDevice;
             createCameraPreviewSession();
         }

         @Override
         public void onDisconnected(CameraDevice cameraDevice) {
             cameraDevice.close();
             mCameraDevice = null;
         }

         @Override
         public void onError(CameraDevice cameraDevice, int error) {
             cameraDevice.close();
             mCameraDevice = null;
             Activity activity = getActivity();
             if (null != activity) {
                 activity.finish();
             }
         }

     };

     /**
      * An additional thread for running tasks that shouldn't block the UI.
      */
     private HandlerThread mBackgroundThread;

     /**
      * A {@link Handler} for running tasks in the background.
      */
     private Handler mBackgroundHandler;

     /**
      * An {@link ImageReader} that handles still image capture.
      */
     private ImageReader mImageReader;

     /**
      * This is the output file for our picture.
      */
     private File mFile;

     /**
      * This a callback object for the {@link ImageReader}. "onImageAvailable" will be called when a
      * still image is ready to be saved.
      */
     private final ImageReader.OnImageAvailableListener mOnImageAvailableListener
             = new ImageReader.OnImageAvailableListener() {

         @Override
         public void onImageAvailable(ImageReader reader) {
             mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));
         }

     };

     /**
      * Given {@code choices} of {@code Size}s supported by a camera, chooses the smallest one whose
      * width and height are at least as large as the respective requested values, and whose aspect
      * ratio matches with the specified value.
      *
      * @param choices     The list of sizes that the camera supports for the intended output class
      * @param width       The minimum desired width
      * @param height      The minimum desired height
      * @param aspectRatio The aspect ratio
      * @return The optimal {@code Size}, or an arbitrary one if none were big enough
      */
     private static Size chooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio) {
         // Collect the supported resolutions that are at least as big as the preview Surface
         List<Size> bigEnough = new ArrayList<Size>();
         int w = aspectRatio.getWidth();
         int h = aspectRatio.getHeight();
         for (Size option : choices) {
             if (option.getHeight() == option.getWidth() * h / w &&
                     option.getWidth() >= width && option.getHeight() >= height) {
                 bigEnough.add(option);
             }
         }

         // Pick the smallest of those, assuming we found any
         if (bigEnough.size() > 0) {
             return Collections.min(bigEnough, new CompareSizesByArea());
         } else {
             Log.e(TAG, "Couldn't find any suitable preview size");
             return choices[0];
         }
     }

     public static Camera2BasicFragment newInstance() {
         Camera2BasicFragment fragment = new Camera2BasicFragment();
         fragment.setRetainInstance(true);
         return fragment;
     }

     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
                              Bundle savedInstanceState) {
         return inflater.inflate(R.layout.fragment_camera2_basic, container, false);
     }

     @Override
     public void onViewCreated(final View view, Bundle savedInstanceState) {
         view.findViewById(R.id.picture).setOnClickListener(this);
         view.findViewById(R.id.info).setOnClickListener(this);
         mTextureView = (AutoFitTextureView) view.findViewById(R.id.texture);
     }

     @Override
     public void onActivityCreated(Bundle savedInstanceState) {
         super.onActivityCreated(savedInstanceState);
         mFile = new File(getActivity().getExternalFilesDir(null), "pic.jpg");
     }

     @Override
     public void onResume() {
         super.onResume();
         startBackgroundThread();

         // When the screen is turned off and turned back on, the SurfaceTexture is already
         // available, and "onSurfaceTextureAvailable" will not be called. In that case, we can open
         // a camera and start preview from here (otherwise, we wait until the surface is ready in
         // the SurfaceTextureListener).
         if (mTextureView.isAvailable()) {
             openCamera(mTextureView.getWidth(), mTextureView.getHeight());
         } else {
             mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
         }
     }

     @Override
     public void onPause() {
         closeCamera();
         stopBackgroundThread();
         super.onPause();
     }

     /**
      * Sets up member variables related to camera.
      *
      * @param width  The width of available size for camera preview
      * @param height The height of available size for camera preview
      */
     private void setUpCameraOutputs(int width, int height) {
         Activity activity = getActivity();
         CameraManager manager = (CameraManager) activity.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.
                 if (characteristics.get(CameraCharacteristics.LENS_FACING)
                         == CameraCharacteristics.LENS_FACING_FRONT) {
                     continue;
                 }

                 StreamConfigurationMap map = characteristics.get(
                         CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

                 // For still image captures, we use the largest available size.
                 Size largest = Collections.max(
                         Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)),
                         new CompareSizesByArea());
                 mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(),
                         ImageFormat.JPEG, /*maxImages*/2);
                 mImageReader.setOnImageAvailableListener(
                         mOnImageAvailableListener, mBackgroundHandler);

                 // Danger, W.R.! Attempting to use too large a preview size could  exceed the camera
                 // bus' bandwidth limitation, resulting in gorgeous previews but the storage of
                 // garbage capture data.
                 mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class),
                         width, height, largest);

                 // We fit the aspect ratio of TextureView to the size of preview we picked.
                 int orientation = getResources().getConfiguration().orientation;
                 if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                     mTextureView.setAspectRatio(
                             mPreviewSize.getWidth(), mPreviewSize.getHeight());
                 } else {
                     mTextureView.setAspectRatio(
                             mPreviewSize.getHeight(), mPreviewSize.getWidth());
                 }

                 mCameraId = cameraId;
                 return;
             }
         } catch (CameraAccessException e) {
             e.printStackTrace();
         } catch (NullPointerException e) {
             // Currently an NPE is thrown when the Camera2API is used but not supported on the
             // device this code runs.
             new ErrorDialog().show(getFragmentManager(), "dialog");
         }
     }

     /**
      * Opens the camera specified by {@link Camera2BasicFragment#mCameraId}.
      */
     private void openCamera(int width, int height) {
         setUpCameraOutputs(width, height);
         configureTransform(width, height);
         Activity activity = getActivity();
         CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
         try {
             manager.openCamera(mCameraId, mStateListener, mBackgroundHandler);
         } catch (CameraAccessException e) {
             e.printStackTrace();
         }
     }

     /**
      * Closes the current {@link CameraDevice}.
      */
     private void closeCamera() {
         if (null != mCaptureSession) {
             mCaptureSession.close();
             mCaptureSession = null;
         }
         if (null != mCameraDevice) {
             mCameraDevice.close();
             mCameraDevice = null;
         }
         if (null != mImageReader) {
             mImageReader.close();
             mImageReader = null;
         }
     }

     /**
      * Starts a background thread and its {@link Handler}.
      */
     private void startBackgroundThread() {
         mBackgroundThread = new HandlerThread("CameraBackground");
         mBackgroundThread.start();
         mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
     }

     /**
      * Stops the background thread and its {@link Handler}.
      */
     private void stopBackgroundThread() {
         mBackgroundThread.quitSafely();
         try {
             mBackgroundThread.join();
             mBackgroundThread = null;
             mBackgroundHandler = null;
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     /**
      * Creates a new {@link CameraCaptureSession} for camera preview.
      */
     private void createCameraPreviewSession() {
         try {
             SurfaceTexture texture = mTextureView.getSurfaceTexture();
             assert texture != null;

             // We configure the size of default buffer to be the size of camera preview we want.
             texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());

             // This is the output Surface we need to start preview.
             Surface surface = new Surface(texture);

             // We set up a CaptureRequest.Builder with the output Surface.
             final CaptureRequest.Builder requestBuilder
                     = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
             requestBuilder.addTarget(surface);

             // Here, we create a CameraCaptureSession for camera preview.
             mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
                     new CameraCaptureSession.StateListener() {

                         @Override
                         public void onConfigured(CameraCaptureSession cameraCaptureSession) {
                             // When the session is ready, we start displaying the preview.
                             mCaptureSession = cameraCaptureSession;
                             try {
                                 // Camera preview can be run in a background thread.
                                 setUpCaptureRequestBuilder(requestBuilder);

                                 // Finally, we start displaying the camera preview.
                                 mCaptureSession.setRepeatingRequest(requestBuilder.build(), null,
                                         mBackgroundHandler);
                             } catch (CameraAccessException e) {
                                 e.printStackTrace();
                             }
                         }

                         @Override
                         public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
                             Activity activity = getActivity();
                             if (null != activity) {
                                 Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
                             }
                         }
                     }, null
             );
         } catch (CameraAccessException e) {
             e.printStackTrace();
         }
     }

     /**
      * Fills in parameters of the {@link CaptureRequest.Builder}.
      *
      * @param builder The builder for a {@link CaptureRequest}
      */
     private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) {
         // In this sample, we just let the camera device pick the automatic settings.
         builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
     }

     /**
      * Configures the necessary {@link android.graphics.Matrix} transformation to `mTextureView`.
      * This method should be called after the camera preview size is determined in
      * setUpCameraOutputs and also the size of `mTextureView` is fixed.
      *
      * @param viewWidth  The width of `mTextureView`
      * @param viewHeight The height of `mTextureView`
      */
     private void configureTransform(int viewWidth, int viewHeight) {
         Activity activity = getActivity();
         if (null == mTextureView || null == mPreviewSize || null == activity) {
             return;
         }
         int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
         Matrix matrix = new Matrix();
         RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
         RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
         float centerX = viewRect.centerX();
         float centerY = viewRect.centerY();
         if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
             bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
             matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
             float scale = Math.max(
                     (float) viewHeight / mPreviewSize.getHeight(),
                     (float) viewWidth / mPreviewSize.getWidth());
             matrix.postScale(scale, scale, centerX, centerY);
             matrix.postRotate(90 * (rotation - 2), centerX, centerY);
         }
         mTextureView.setTransform(matrix);
     }

     /**
      * Takes a picture.
      */
     private void takePicture() {
         try {
             final Activity activity = getActivity();
             if (null == activity || 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(mImageReader.getSurface());
             setUpCaptureRequestBuilder(captureBuilder);

             // Orientation
             int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
             captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));

             CameraCaptureSession.CaptureListener captureListener
                     = new CameraCaptureSession.CaptureListener() {
                 @Override
                 public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request,
                                                TotalCaptureResult result) {
                     Toast.makeText(getActivity(), "Saved: " + mFile, Toast.LENGTH_SHORT).show();
                 }
             };

             mCaptureSession.capture(captureBuilder.build(), captureListener, /*handler*/null);
         } catch (CameraAccessException e) {
             e.printStackTrace();
         }
     }

     @Override
     public void onClick(View view) {
         switch (view.getId()) {
             case R.id.picture: {
                 takePicture();
                 break;
             }
             case R.id.info: {
                 Activity activity = getActivity();
                 if (null != activity) {
                     new AlertDialog.Builder(activity)
                             .setMessage(R.string.intro_message)
                             .setPositiveButton(android.R.string.ok, null)
                             .show();
                 }
                 break;
             }
         }
     }

     /**
      * Saves a JPEG {@link Image} into the specified {@link File}.
      */
     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 (FileNotFoundException e) {
                 e.printStackTrace();
             } catch (IOException e) {
                 e.printStackTrace();
             } finally {
                 mImage.close();
                 if (null != output) {
                     try {
                         output.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }

     }

     /**
      * Compares two {@code Size}s based on their areas.
      */
     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());
         }

     }

     public static class ErrorDialog extends DialogFragment {

         @Override
         public Dialog onCreateDialog(Bundle savedInstanceState) {
             final Activity activity = getActivity();
             return new AlertDialog.Builder(activity)
                     .setMessage("This device doesn't support Camera2 API.")
                     .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                         @Override
                         public void onClick(DialogInterface dialogInterface, int i) {
                             activity.finish();
                         }
                     })
                     .create();
         }

     }

 }
	/*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.example.android.camera2basic;

	import android.app.Activity;
	import android.app.AlertDialog;
	import android.app.Dialog;
	import android.app.DialogFragment;
	import android.app.Fragment;
	import android.content.Context;
	import android.content.DialogInterface;
	import android.content.res.Configuration;
	import android.graphics.ImageFormat;
	import android.graphics.Matrix;
	import android.graphics.RectF;
	import android.graphics.SurfaceTexture;
	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.CameraMetadata;
	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.Bundle;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.util.Log;
	import android.util.Size;
	import android.util.SparseIntArray;
	import android.view.LayoutInflater;
	import android.view.Surface;
	import android.view.TextureView;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.Toast;

	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.nio.ByteBuffer;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.List;

	public class Camera2BasicFragment extends Fragment implements View.OnClickListener {

	/**
	* Conversion from screen rotation to JPEG orientation.
	*/
	private static final SparseIntArray ORIENTATIONS = new SparseIntArray();

	static {
	ORIENTATIONS.append(Surface.ROTATION_0, 90);
	ORIENTATIONS.append(Surface.ROTATION_90, 0);
	ORIENTATIONS.append(Surface.ROTATION_180, 270);
	ORIENTATIONS.append(Surface.ROTATION_270, 180);
	}

	private static final String TAG = "Camera2BasicFragment";

	/**
	* {@link TextureView.SurfaceTextureListener} handles several lifecycle events on a
	* {@link TextureView}.
	*/
	private final TextureView.SurfaceTextureListener mSurfaceTextureListener
	= new TextureView.SurfaceTextureListener() {

	@Override
	public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) {
	openCamera(width, height);
	}

	@Override
	public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) {
	configureTransform(width, height);
	}

	@Override
	public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
	return true;
	}

	@Override
	public void onSurfaceTextureUpdated(SurfaceTexture texture) {
	}

	};

	/**
	* ID of the current {@link CameraDevice}.
	*/
	private String mCameraId;

	/**
	* An {@link AutoFitTextureView} for camera preview.
	*/
	private AutoFitTextureView mTextureView;

	/**
	* A {@link CameraCaptureSession } for camera preview.
	*/

	private CameraCaptureSession mCaptureSession;
	/**
	* A reference to the opened {@link CameraDevice}.
	*/

	private CameraDevice mCameraDevice;
	/**
	* The {@link android.util.Size} of camera preview.
	*/

	private Size mPreviewSize;

	/**
	* {@link CameraDevice.StateListener} is called when {@link CameraDevice} changes its state.
	*/
	private final CameraDevice.StateListener mStateListener = new CameraDevice.StateListener() {

	@Override
	public void onOpened(CameraDevice cameraDevice) {
	// This method is called when the camera is opened. We start camera preview here.
	mCameraDevice = cameraDevice;
	createCameraPreviewSession();
	}

	@Override
	public void onDisconnected(CameraDevice cameraDevice) {
	cameraDevice.close();
	mCameraDevice = null;
	}

	@Override
	public void onError(CameraDevice cameraDevice, int error) {
	cameraDevice.close();
	mCameraDevice = null;
	Activity activity = getActivity();
	if (null != activity) {
	activity.finish();
	}
	}

	};

	/**
	* An additional thread for running tasks that shouldn't block the UI.
	*/
	private HandlerThread mBackgroundThread;

	/**
	* A {@link Handler} for running tasks in the background.
	*/
	private Handler mBackgroundHandler;

	/**
	* An {@link ImageReader} that handles still image capture.
	*/
	private ImageReader mImageReader;

	/**
	* This is the output file for our picture.
	*/
	private File mFile;

	/**
	* This a callback object for the {@link ImageReader}. "onImageAvailable" will be called when a
	* still image is ready to be saved.
	*/
	private final ImageReader.OnImageAvailableListener mOnImageAvailableListener
	= new ImageReader.OnImageAvailableListener() {

	@Override
	public void onImageAvailable(ImageReader reader) {
	mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));
	}

	};

	/**
	* Given {@code choices} of {@code Size}s supported by a camera, chooses the smallest one whose
	* width and height are at least as large as the respective requested values, and whose aspect
	* ratio matches with the specified value.
	*
	* @param choices The list of sizes that the camera supports for the intended output class
	* @param width The minimum desired width
	* @param height The minimum desired height
	* @param aspectRatio The aspect ratio
	* @return The optimal {@code Size}, or an arbitrary one if none were big enough
	*/
	private static Size chooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio) {
	// Collect the supported resolutions that are at least as big as the preview Surface
	List<Size> bigEnough = new ArrayList<Size>();
	int w = aspectRatio.getWidth();
	int h = aspectRatio.getHeight();
	for (Size option : choices) {
	if (option.getHeight() == option.getWidth() * h / w &&
	option.getWidth() >= width && option.getHeight() >= height) {
	bigEnough.add(option);
	}
	}

	// Pick the smallest of those, assuming we found any
	if (bigEnough.size() > 0) {
	return Collections.min(bigEnough, new CompareSizesByArea());
	} else {
	Log.e(TAG, "Couldn't find any suitable preview size");
	return choices[0];
	}
	}

	public static Camera2BasicFragment newInstance() {
	Camera2BasicFragment fragment = new Camera2BasicFragment();
	fragment.setRetainInstance(true);
	return fragment;
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
	Bundle savedInstanceState) {
	return inflater.inflate(R.layout.fragment_camera2_basic, container, false);
	}

	@Override
	public void onViewCreated(final View view, Bundle savedInstanceState) {
	view.findViewById(R.id.picture).setOnClickListener(this);
	view.findViewById(R.id.info).setOnClickListener(this);
	mTextureView = (AutoFitTextureView) view.findViewById(R.id.texture);
	}

	@Override
	public void onActivityCreated(Bundle savedInstanceState) {
	super.onActivityCreated(savedInstanceState);
	mFile = new File(getActivity().getExternalFilesDir(null), "pic.jpg");
	}

	@Override
	public void onResume() {
	super.onResume();
	startBackgroundThread();

	// When the screen is turned off and turned back on, the SurfaceTexture is already
	// available, and "onSurfaceTextureAvailable" will not be called. In that case, we can open
	// a camera and start preview from here (otherwise, we wait until the surface is ready in
	// the SurfaceTextureListener).
	if (mTextureView.isAvailable()) {
	openCamera(mTextureView.getWidth(), mTextureView.getHeight());
	} else {
	mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
	}
	}

	@Override
	public void onPause() {
	closeCamera();
	stopBackgroundThread();
	super.onPause();
	}

	/**
	* Sets up member variables related to camera.
	*
	* @param width The width of available size for camera preview
	* @param height The height of available size for camera preview
	*/
	private void setUpCameraOutputs(int width, int height) {
	Activity activity = getActivity();
	CameraManager manager = (CameraManager) activity.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.
	if (characteristics.get(CameraCharacteristics.LENS_FACING)
	== CameraCharacteristics.LENS_FACING_FRONT) {
	continue;
	}

	StreamConfigurationMap map = characteristics.get(
	CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

	// For still image captures, we use the largest available size.
	Size largest = Collections.max(
	Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)),
	new CompareSizesByArea());
	mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(),
	ImageFormat.JPEG, /maxImages/2);
	mImageReader.setOnImageAvailableListener(
	mOnImageAvailableListener, mBackgroundHandler);

	// Danger, W.R.! Attempting to use too large a preview size could exceed the camera
	// bus' bandwidth limitation, resulting in gorgeous previews but the storage of
	// garbage capture data.
	mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class),
	width, height, largest);

	// We fit the aspect ratio of TextureView to the size of preview we picked.
	int orientation = getResources().getConfiguration().orientation;
	if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
	mTextureView.setAspectRatio(
	mPreviewSize.getWidth(), mPreviewSize.getHeight());
	} else {
	mTextureView.setAspectRatio(
	mPreviewSize.getHeight(), mPreviewSize.getWidth());
	}

	mCameraId = cameraId;
	return;
	}
	} catch (CameraAccessException e) {
	e.printStackTrace();
	} catch (NullPointerException e) {
	// Currently an NPE is thrown when the Camera2API is used but not supported on the
	// device this code runs.
	new ErrorDialog().show(getFragmentManager(), "dialog");
	}
	}

	/**
	* Opens the camera specified by {@link Camera2BasicFragment#mCameraId}.
	*/
	private void openCamera(int width, int height) {
	setUpCameraOutputs(width, height);
	configureTransform(width, height);
	Activity activity = getActivity();
	CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
	try {
	manager.openCamera(mCameraId, mStateListener, mBackgroundHandler);
	} catch (CameraAccessException e) {
	e.printStackTrace();
	}
	}

	/**
	* Closes the current {@link CameraDevice}.
	*/
	private void closeCamera() {
	if (null != mCaptureSession) {
	mCaptureSession.close();
	mCaptureSession = null;
	}
	if (null != mCameraDevice) {
	mCameraDevice.close();
	mCameraDevice = null;
	}
	if (null != mImageReader) {
	mImageReader.close();
	mImageReader = null;
	}
	}

	/**
	* Starts a background thread and its {@link Handler}.
	*/
	private void startBackgroundThread() {
	mBackgroundThread = new HandlerThread("CameraBackground");
	mBackgroundThread.start();
	mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
	}

	/**
	* Stops the background thread and its {@link Handler}.
	*/
	private void stopBackgroundThread() {
	mBackgroundThread.quitSafely();
	try {
	mBackgroundThread.join();
	mBackgroundThread = null;
	mBackgroundHandler = null;
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}

	/**
	* Creates a new {@link CameraCaptureSession} for camera preview.
	*/
	private void createCameraPreviewSession() {
	try {
	SurfaceTexture texture = mTextureView.getSurfaceTexture();
	assert texture != null;

	// We configure the size of default buffer to be the size of camera preview we want.
	texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());

	// This is the output Surface we need to start preview.
	Surface surface = new Surface(texture);

	// We set up a CaptureRequest.Builder with the output Surface.
	final CaptureRequest.Builder requestBuilder
	= mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
	requestBuilder.addTarget(surface);

	// Here, we create a CameraCaptureSession for camera preview.
	mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
	new CameraCaptureSession.StateListener() {

	@Override
	public void onConfigured(CameraCaptureSession cameraCaptureSession) {
	// When the session is ready, we start displaying the preview.
	mCaptureSession = cameraCaptureSession;
	try {
	// Camera preview can be run in a background thread.
	setUpCaptureRequestBuilder(requestBuilder);

	// Finally, we start displaying the camera preview.
	mCaptureSession.setRepeatingRequest(requestBuilder.build(), null,
	mBackgroundHandler);
	} catch (CameraAccessException e) {
	e.printStackTrace();
	}
	}

	@Override
	public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
	Activity activity = getActivity();
	if (null != activity) {
	Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
	}
	}
	}, null
	);
	} catch (CameraAccessException e) {
	e.printStackTrace();
	}
	}

	/**
	* Fills in parameters of the {@link CaptureRequest.Builder}.
	*
	* @param builder The builder for a {@link CaptureRequest}
	*/
	private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) {
	// In this sample, we just let the camera device pick the automatic settings.
	builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
	}

	/**
	* Configures the necessary {@link android.graphics.Matrix} transformation to `mTextureView`.
	* This method should be called after the camera preview size is determined in
	* setUpCameraOutputs and also the size of `mTextureView` is fixed.
	*
	* @param viewWidth The width of `mTextureView`
	* @param viewHeight The height of `mTextureView`
	*/
	private void configureTransform(int viewWidth, int viewHeight) {
	Activity activity = getActivity();
	if (null == mTextureView \|\| null == mPreviewSize \|\| null == activity) {
	return;
	}
	int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
	Matrix matrix = new Matrix();
	RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
	RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
	float centerX = viewRect.centerX();
	float centerY = viewRect.centerY();
	if (Surface.ROTATION_90 == rotation \|\| Surface.ROTATION_270 == rotation) {
	bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
	matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
	float scale = Math.max(
	(float) viewHeight / mPreviewSize.getHeight(),
	(float) viewWidth / mPreviewSize.getWidth());
	matrix.postScale(scale, scale, centerX, centerY);
	matrix.postRotate(90 * (rotation - 2), centerX, centerY);
	}
	mTextureView.setTransform(matrix);
	}

	/**
	* Takes a picture.
	*/
	private void takePicture() {
	try {
	final Activity activity = getActivity();
	if (null == activity \|\| 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(mImageReader.getSurface());
	setUpCaptureRequestBuilder(captureBuilder);

	// Orientation
	int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
	captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));

	CameraCaptureSession.CaptureListener captureListener
	= new CameraCaptureSession.CaptureListener() {
	@Override
	public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request,
	TotalCaptureResult result) {
	Toast.makeText(getActivity(), "Saved: " + mFile, Toast.LENGTH_SHORT).show();
	}
	};

	mCaptureSession.capture(captureBuilder.build(), captureListener, /handler/null);
	} catch (CameraAccessException e) {
	e.printStackTrace();
	}
	}

	@Override
	public void onClick(View view) {
	switch (view.getId()) {
	case R.id.picture: {
	takePicture();
	break;
	}
	case R.id.info: {
	Activity activity = getActivity();
	if (null != activity) {
	new AlertDialog.Builder(activity)
	.setMessage(R.string.intro_message)
	.setPositiveButton(android.R.string.ok, null)
	.show();
	}
	break;
	}
	}
	}

	/**
	* Saves a JPEG {@link Image} into the specified {@link File}.
	*/
	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 (FileNotFoundException e) {
	e.printStackTrace();
	} catch (IOException e) {
	e.printStackTrace();
	} finally {
	mImage.close();
	if (null != output) {
	try {
	output.close();
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	}
	}

	}

	/**
	* Compares two {@code Size}s based on their areas.
	*/
	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());
	}

	}

	public static class ErrorDialog extends DialogFragment {

	@Override
	public Dialog onCreateDialog(Bundle savedInstanceState) {
	final Activity activity = getActivity();
	return new AlertDialog.Builder(activity)
	.setMessage("This device doesn't support Camera2 API.")
	.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
	@Override
	public void onClick(DialogInterface dialogInterface, int i) {
	activity.finish();
	}
	})
	.create();
	}

	}

	}