public class MainActivity extends AppCompatActivity {
  static final String TAG = "CAMERA ACTIVITY";

  //Camera object
  Camera mCamera;
  //Preview surface
  SurfaceView surfaceView;
  //Preview surface handle for callback
  SurfaceHolder surfaceHolder;
  //Camera button
  Button btnCapture;
  //Note if preview windows is on.
  boolean previewing;

  int mCurrentCamIndex = 0;
  private AudioManager manager;
  private int volumn;
  private boolean canTake=false;
  private ImageView imageView;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    btnCapture = (Button) findViewById(R.id.btn_capture);
    imageView =(ImageView)findViewById(R.id.iv);
    btnCapture.setOnClickListener(new Button.OnClickListener() {
      public void onClick(View arg0) {
        canTake=true;
      }
    });

    surfaceView = (SurfaceView) findViewById(R.id.surfaceView1);
    surfaceHolder = surfaceView.getHolder();
    surfaceHolder.addCallback(new SurfaceViewCallback());
    //surfaceHolder.addCallback(this);
    surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

  }

  public void getSurfacePic(byte[] data, Camera camera,String name){
    Camera.Size size = camera.getParameters().getPreviewSize();
    YuvImage image = new YuvImage(data, ImageFormat.NV21, size.width, size.height, null);
    if(image!=null){
      ByteArrayOutputStream stream = new ByteArrayOutputStream();
      image.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, stream);

      Bitmap bmp = BitmapFactory.decodeByteArray(stream.toByteArray(), 0, stream.size());

      //**********************
      //因为图片会放生旋转，因此要对图片进行旋转到和手机在一个方向上
      rotateMyBitmap(bmp,name);
      //**********************************


    }
  }

  /** 保存方法 */
  public void saveBitmap(Bitmap bm,String name) {
    Log.e(TAG, "保存图片");
    File f = new File("/sdcard/namecard/", name);
    if (f.exists()) {
      f.delete();
    }
    try {
      FileOutputStream out = new FileOutputStream(f);
      bm.compress(Bitmap.CompressFormat.PNG, 90, out);
      out.flush();
      out.close();
      Log.e(TAG, "已经保存");
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }

  /**
   * 保存图片到指定文件夹
   *
   * @param bmp
   * @return
   */
  private boolean saveBitmapTofile(byte[] bmp) {
    String fileName = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)
        .toString()
        + File.separator
        + "PicTest_" + System.currentTimeMillis() + ".jpg";
    File file = new File(fileName);
    if (!file.getParentFile().exists()) {
      file.getParentFile().mkdir();
    }

    try {
      BufferedOutputStream bos = new BufferedOutputStream(
          new FileOutputStream(file));
      bos.write(bmp);
      bos.flush();
      bos.close();
      scanFileToPhotoAlbum(file.getAbsolutePath());
      Toast.makeText(MainActivity.this, "[Test] Photo take and store in" + file.toString(),Toast.LENGTH_LONG).show();
    } catch (Exception e) {
      Toast.makeText(MainActivity.this, "Picture Failed" + e.toString(),
          Toast.LENGTH_LONG).show();
    }
    return true;
  }

  public void saveMyBitmap(Bitmap mBitmap,String bitName) {
    String fileName = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)
        .toString()
        + File.separator
        + "PicTest_" + System.currentTimeMillis() + ".jpg";
    File file = new File(fileName);
    if (!file.getParentFile().exists()) {
      file.getParentFile().mkdir();
    }
    FileOutputStream fOut = null;
    try {
      fOut = new FileOutputStream(file);
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }

    try {
      if (null != fOut) {
        mBitmap.compress(Bitmap.CompressFormat.JPEG, 100, fOut);
        fOut.flush();
        fOut.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }

  }

  public void rotateMyBitmap(Bitmap bmp,String name){
    //*****旋转一下
    Matrix matrix = new Matrix();
    matrix.postRotate(270);

    Bitmap bitmap = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), Bitmap.Config.RGB_565);

    Bitmap nbmp2 = Bitmap.createBitmap(bmp, 0,0, bmp.getWidth(), bmp.getHeight(), matrix, true);

    saveMyBitmap(compressImage(nbmp2),"cool");

    //*******显示一下
    imageView.setImageBitmap(nbmp2);

  };
  /**
   * 压缩图片
   *
   * @param image
   * @return
   */
  public static Bitmap compressImage(Bitmap image) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    // 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
    image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    // 把压缩后的数据baos存放到ByteArrayInputStream中
    ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
    // 把ByteArrayInputStream数据生成图片
    Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);
    return bitmap;
  }



  Camera.ShutterCallback shutterCallback = new Camera.ShutterCallback() {
    @Override
    public void onShutter() {
    }
  };

  Camera.PictureCallback rawPictureCallback = new Camera.PictureCallback() {
    @Override
    public void onPictureTaken(byte[] arg0, Camera arg1) {

    }
  };

  Camera.PictureCallback jpegPictureCallback = new Camera.PictureCallback() {
    @Override
    public void onPictureTaken(byte[] arg0, Camera arg1) {

      String fileName = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)
          .toString()
          + File.separator
          + "PicTest_" + System.currentTimeMillis() + ".jpg";
      File file = new File(fileName);
      if (!file.getParentFile().exists()) {
        file.getParentFile().mkdir();
      }

      try {
        BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(file));
        bos.write(arg0);
        bos.flush();
        bos.close();
        scanFileToPhotoAlbum(file.getAbsolutePath());
        Toast.makeText(MainActivity.this, "[Test] Photo take and store in" + file.toString(),Toast.LENGTH_LONG).show();
      } catch (Exception e) {
        Toast.makeText(MainActivity.this, "Picture Failed" + e.toString(),
            Toast.LENGTH_LONG).show();
      }
    };
  };

  public void setVolumnSilence(){
    manager = (AudioManager) this
        .getSystemService(Context.AUDIO_SERVICE);
    manager.setStreamMute(AudioManager.STREAM_SYSTEM, false);
    volumn = manager.getStreamVolume(AudioManager.STREAM_SYSTEM);
    if (volumn != 0) {
      // 如果需要静音并且当前未静音（muteMode的设置可以放在Preference中）
      manager.setStreamVolume(AudioManager.STREAM_SYSTEM, 0,
          AudioManager.FLAG_REMOVE_SOUND_AND_VIBRATE);
    }
  }

  public void scanFileToPhotoAlbum(String path) {

    MediaScannerConnection.scanFile(MainActivity.this,
        new String[] { path }, null,
        new MediaScannerConnection.OnScanCompletedListener() {

          public void onScanCompleted(String path, Uri uri) {
            Log.i("TAG", "Finished scanning " + path);
          }
        });
  }

  public void cameraRefresh(String picPath) {
    Toast.makeText(this,picPath,Toast.LENGTH_SHORT).show();
  }

  private final class SurfaceViewCallback implements android.view.SurfaceHolder.Callback {
    public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3)
    {
      if (previewing) {
        mCamera.stopPreview();
        previewing = false;
      }

      try {
        mCamera.setPreviewDisplay(arg0);
        mCamera.startPreview();
        previewing = true;
        setCameraDisplayOrientation(MainActivity.this, mCurrentCamIndex, mCamera);
      } catch (Exception e) {}
    }
    public void surfaceCreated(SurfaceHolder holder) {
//       mCamera = Camera.open();
      //change to front camera
      mCamera = openFrontFacingCameraGingerbread();
      // get Camera parameters
      Camera.Parameters params = mCamera.getParameters();

      List<String> focusModes = params.getSupportedFocusModes();
      if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
        // Autofocus mode is supported
      }
      mCamera.setPreviewCallback(new Camera.PreviewCallback() {
        @Override
        public void onPreviewFrame(byte[] bytes, Camera camera) {
          Log.e("stuart","onPreviewFrame "+canTake);
          if(canTake) {
            getSurfacePic(bytes, camera, "hahahaah");
            canTake=false;
          }
        }
      });
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
      mCamera.stopPreview();
      mCamera.release();
      mCamera = null;
      previewing = false;
    }


  }

  private Camera openFrontFacingCameraGingerbread() {
    int cameraCount = 0;
    Camera cam = null;
    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    cameraCount = Camera.getNumberOfCameras();

    for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
      Camera.getCameraInfo(camIdx, cameraInfo);
      if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        try {
          cam = Camera.open(camIdx);
          mCurrentCamIndex = camIdx;
        } catch (RuntimeException e) {
          Log.e(TAG, "Camera failed to open: " + e.getLocalizedMessage());
        }
      }
    }

    return cam;
  }

  private static void setCameraDisplayOrientation(Activity activity, int cameraId, Camera camera)
  {
    Camera.CameraInfo info = new Camera.CameraInfo();
    Camera.getCameraInfo(cameraId, info);
    int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();

    //degrees the angle that the picture will be rotated clockwise. Valid values are 0, 90, 180, and 270.
    //The starting position is 0 (landscape).
    int degrees = 0;
    switch (rotation)
    {
      case Surface.ROTATION_0: degrees = 0; break;
      case Surface.ROTATION_90: degrees = 90; break;
      case Surface.ROTATION_180: degrees = 180; break;
      case Surface.ROTATION_270: degrees = 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;
    }
    camera.setDisplayOrientation(result);
  }
}