Index: ActivityCapture.java
===================================================================
--- ActivityCapture.java (revision 0)
ActivityCapture.java (revision 3)
@@ -0,0 +1,638 @@
package com.cn.commoncamera; import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.hardware.Camera;
import android.hardware.Camera.CameraInfo;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.Size;
import android.os.Bundle;
import android.util.Log;
import android.view.*;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.Toast; import java.io.File;
import java.util.List; import com.cn.camerautils.BitmapUtil;
import com.cn.camerautils.Debug;
import com.cn.camerautils.PathManager;
import com.cn.qsign.R; @SuppressLint("NewApi")
//默认的相机为横平，所以Activity设置为横屏，拍出的照片才正确
public class ActivityCapture extends Activity implements
View.OnClickListener, CaptureSensorsObserver.RefocuseListener {
private ImageView bnToggleCamera;
private ImageView bnCapture; private RelativeLayout layback;
private FrameLayout framelayoutPreview;
private CameraPreview preview;
private CameraCropBorderView cropBorderView;
private Camera camera;
private PictureCallback pictureCallBack;
private Camera.AutoFocusCallback focusCallback;
private CaptureSensorsObserver observer;
private View focuseView; private int currentCameraId;
private int frontCameraId;
private boolean _isCapturing; CaptureOrientationEventListener _orientationEventListener;
private int _rotation; public static final int kPhotoMaxSaveSideLen = 1600;
public static final String kPhotoPath = "photo_path"; // private ShutterCallback _shutterCallback = new ShutterCallback() {
// @Override
// public void onShutter() {
// }
// }; final static String TAG = "capture"; @Override
protected void onCreate(Bundle savedInstanceState) {
observer = new CaptureSensorsObserver(this);
_orientationEventListener = new CaptureOrientationEventListener(this);
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_capture);
getViews();
initViews();
setListeners();
setupDevice(); } @Override
protected void onDestroy() {
if (null != observer) {
observer.setRefocuseListener(null);
observer = null;
}
_orientationEventListener = null; super.onDestroy();
} @Override
protected void onPause() {
super.onPause();
releaseCamera(); // release the camera immediately on pause event observer.stop();
_orientationEventListener.disable();
} @Override
protected void onResume() {
super.onResume();
//openCamera();
switchCamera();
} private void releaseCamera() {
if (camera != null) {
camera.release(); // release the camera for other applications
camera = null;
} if (null != preview) {
framelayoutPreview.removeAllViews();
preview = null;
}
} protected void getViews() {
bnToggleCamera = (ImageView) findViewById(R.id.bnToggleCamera);
bnCapture = (ImageView) findViewById(R.id.bnCapture);
framelayoutPreview = (FrameLayout) findViewById(R.id.cameraPreview);
focuseView = findViewById(R.id.viewFocuse);
layback=(RelativeLayout)findViewById(R.id.layback);
} protected void initViews() {
bnCapture.setRotation(-90);
bnToggleCamera.setRotation(-90);
} protected void setListeners() {
bnToggleCamera.setOnClickListener(this);
bnCapture.setOnClickListener(this);
observer.setRefocuseListener(this);
layback.setOnClickListener(this);
pictureCallBack = new PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera) {
_isCapturing = false;
Bitmap bitmap = null;
try {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(data, 0, data.length, options);
// Debug.debug("width--:" + options.outWidth + " height--:" + options.outHeight);
options.inJustDecodeBounds = false;
options.inPreferredConfig = Bitmap.Config.ARGB_8888;
//此处就把图片压缩了
options.inSampleSize = Math.max(options.outWidth
/ kPhotoMaxSaveSideLen, options.outHeight
/ kPhotoMaxSaveSideLen);
bitmap = BitmapUtil.decodeByteArrayUnthrow(data, options);
if (null == bitmap) {
options.inSampleSize = Math.max(2, options.inSampleSize * 2);
bitmap = BitmapUtil.decodeByteArrayUnthrow(data, options);
}
} catch (Throwable e) {
}
if (null == bitmap) {
Toast.makeText(ActivityCapture.this, "内存不足，保存照片失败！", Toast.LENGTH_SHORT).show();
return;
}
//long start = System.currentTimeMillis();
Bitmap addBitmap = BitmapUtil.rotateAndScale(bitmap, _rotation, kPhotoMaxSaveSideLen, true);
Bitmap finalBitmap = cropPhotoImage(addBitmap);
File photoFile = PathManager.getCropPhotoPath();
boolean successful = BitmapUtil.saveBitmap2file(finalBitmap, photoFile, Bitmap.CompressFormat.JPEG, 100);
while (!successful) {
successful = BitmapUtil.saveBitmap2file(finalBitmap, photoFile, Bitmap.CompressFormat.JPEG, 100);
}
if (finalBitmap != null && !finalBitmap.isRecycled()) {
addBitmap.recycle();
}
Intent intent = new Intent(ActivityCapture.this,ShowImageActivity.class);
intent.putExtra(kPhotoPath, photoFile.getAbsolutePath());
currentCameraId = 0;
ActivityCapture.this.startActivity(intent);
//setResult(1, intent);
//ActivityCapture.this.finish();
}
};
focusCallback = new Camera.AutoFocusCallback() {
@Override
public void onAutoFocus(boolean successed, Camera camera) {
focuseView.setVisibility(View.INVISIBLE);
}
};
} //根据拍照的图片来剪裁
private Bitmap cropPhotoImage(Bitmap bmp) {
int dw = bmp.getWidth();
int dh = bmp.getHeight();
int height;
int width;
if (dh > dw) {//图片竖直方向
//切图片时按照竖屏来计算
height = getWindowManager().getDefaultDisplay().getWidth();
width = getWindowManager().getDefaultDisplay().getHeight();
} else {//图片是水平方向
//切图片时按照横屏来计算
width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();
}
Rect rect = new Rect();
int left = 0;
int top = 0;
int right = width;
int bottom = height;
rect.set(left, top, right, bottom);
float scale = 1.0f;
// 如果图片的宽或者高大于屏幕，则缩放至屏幕的宽或者高
if (dw > width && dh <= height) {
scale = width * 1.0f / dw;
}
if (dh > height && dw <= width) {
scale = height * 1.0f / dh;
}
// 如果宽和高都大于屏幕，则让其按按比例适应屏幕大小
if (dw > width && dh > height) {
scale = Math.max(width * 1.0f / dw, height * 1.0f / dh);
}
//如果图片的宽度和高度都小于屏幕的宽度和高度，则放大至屏幕大小
if (dw < width && dh < height) {
scale = width * 1.0f / dw;
}
Matrix matrix = new Matrix();
matrix.postScale(scale, scale);
try {
Bitmap b2 = Bitmap.createBitmap(bmp, 0, 0, dw, dh, matrix, true);
if (null != b2 && bmp != b2) {
bmp.recycle();
bmp = b2;
}
} catch (OutOfMemoryError e) {
e.printStackTrace();
}
try {
Bitmap b3 = Bitmap.createBitmap(bmp, rect.left, rect.top, rect.width(), rect.height());
if (null != b3 && bmp != b3) {
bmp.recycle();
bmp = b3;
}
} catch (OutOfMemoryError e) {
e.printStackTrace();
}
//将图片压缩至640*640
try {
Bitmap b4 = Bitmap.createScaledBitmap(bmp, 640, 640, false);
if (null != b4 && bmp != b4) {
bmp.recycle();
bmp = b4;
}
} catch (OutOfMemoryError e) {
e.printStackTrace();
}
return bmp;
} private void setupDevice() {
if (android.os.Build.VERSION.SDK_INT > 8) {
int cameraCount = Camera.getNumberOfCameras(); if (cameraCount < 1) {
Toast.makeText(this, "你的设备木有摄像头。。。", Toast.LENGTH_SHORT).show();
finish();
return;
} else if (cameraCount == 1) {
bnToggleCamera.setVisibility(View.INVISIBLE);
} else {
bnToggleCamera.setVisibility(View.VISIBLE);
} currentCameraId = 0;
frontCameraId = findFrontFacingCamera();
if (-1 == frontCameraId) {
bnToggleCamera.setVisibility(View.INVISIBLE);
}
}
} private void openCamera() {
if (android.os.Build.VERSION.SDK_INT > 8) {
try {
camera = Camera.open(currentCameraId);
} catch (Exception e) {
Toast.makeText(this, "摄像头打开失败", Toast.LENGTH_SHORT).show();
finish();
return;
}
setCameraDisplayOrientation(this, 0, camera);
} else {
try {
camera = Camera.open();
} catch (Exception e) {
Toast.makeText(this, "摄像头打开失败", Toast.LENGTH_SHORT).show();
finish();
return;
}
} Camera.Parameters camParmeters = camera.getParameters();
List<Size> sizes = camParmeters.getSupportedPreviewSizes();
for (Size size : sizes) {
Log.v(TAG, "w:" + size.width + ",h:" + size.height);
} preview = new CameraPreview(this, camera);
cropBorderView = new CameraCropBorderView(this);
FrameLayout.LayoutParams params1 = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
FrameLayout.LayoutParams params2 = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
framelayoutPreview.addView(preview, params1);
//framelayoutPreview.addView(cropBorderView, params1);
observer.start();
_orientationEventListener.enable();
} @Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.bnToggleCamera:
switchCamera();
break;
case R.id.bnCapture:
bnCaptureClicked();
break;
case R.id.layback:
finish();
break;
}
} @Override
public void onBackPressed() {
super.onBackPressed();
} //横竖屏切换的时候
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
} private void switchCamera() {
if (currentCameraId == 0) {
currentCameraId = frontCameraId;
} else {
currentCameraId = 0;
}
releaseCamera();
openCamera();
} private void bnCaptureClicked() {
if (_isCapturing) {
return;
}
_isCapturing = true;
focuseView.setVisibility(View.INVISIBLE); try {
camera.takePicture(null, null, pictureCallBack);
} catch (RuntimeException e) {
e.printStackTrace();
_isCapturing = false;
}
} /**
* A basic Camera preview class
*/
public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
private SurfaceHolder mHolder;
private Camera mCamera; @SuppressWarnings("deprecation")
public CameraPreview(Context context, Camera camera) {
super(context);
mCamera = camera; // Install a SurfaceHolder.Callback so we get notified when the
// underlying surface is created and destroyed.
mHolder = getHolder();
mHolder.addCallback(this);
// deprecated setting, but required on Android versions prior to 3.0
mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
} public void surfaceCreated(SurfaceHolder holder) {
// The Surface has been created, now tell the camera where to draw
// the preview.
try {
mCamera.setPreviewDisplay(holder);
mCamera.startPreview();
} catch (Exception e) {
Log.d(TAG, "Error setting camera preview: " + e.getMessage());
}
} public void surfaceDestroyed(SurfaceHolder holder) {
// empty. Take care of releasing the Camera preview in your
// activity.
if (camera != null) {
camera.setPreviewCallback(null);
camera.stopPreview();// 停止预览
camera.release(); // 释放摄像头资源
camera = null;
}
} private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
final double ASPECT_TOLERANCE = 0.05;
double targetRatio = (double) w / h;
if (sizes == null)
return null; Size optimalSize = null;
double minDiff = Double.MAX_VALUE; int targetHeight = h; // Try to find an size match aspect ratio and size
for (Size size : sizes) {
double ratio = (double) size.width / size.height;
if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)
continue;
if (Math.abs(size.height - targetHeight) < minDiff) {
optimalSize = size;
minDiff = Math.abs(size.height - targetHeight);
}
} // Cannot find the one match the aspect ratio, ignore the
// requirement
if (optimalSize == null) {
minDiff = Double.MAX_VALUE;
for (Size size : sizes) {
if (Math.abs(size.height - targetHeight) < minDiff) {
optimalSize = size;
minDiff = Math.abs(size.height - targetHeight);
}
}
} return optimalSize;
} private Size getOptimalPictureSize(List<Size> sizes, double targetRatio) {
final double ASPECT_TOLERANCE = 0.05; if (sizes == null)
return null; Size optimalSize = null;
int optimalSideLen = 0;
double optimalDiffRatio = Double.MAX_VALUE; for (Size size : sizes) { int sideLen = Math.max(size.width, size.height);
//LogEx.i("size.width: " + size.width + ", size.height: " + size.height);
boolean select = false;
if (sideLen < kPhotoMaxSaveSideLen) {
if (0 == optimalSideLen || sideLen > optimalSideLen) {
select = true;
}
} else {
if (kPhotoMaxSaveSideLen > optimalSideLen) {
select = true;
} else {
double diffRatio = Math.abs((double) size.width / size.height - targetRatio);
if (diffRatio + ASPECT_TOLERANCE < optimalDiffRatio) {
select = true;
} else if (diffRatio < optimalDiffRatio + ASPECT_TOLERANCE && sideLen < optimalSideLen) {
select = true;
}
}
} if (select) {
optimalSize = size;
optimalSideLen = sideLen;
optimalDiffRatio = Math.abs((double) size.width / size.height - targetRatio);
}
} return optimalSize;
} public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
// If your preview can change or rotate, take care of those events
// here.
// Make sure to stop the preview before resizing or reformatting it. Debug.debug("surfaceChanged format:" + format + ", w:" + w + ", h:" + h);
if (mHolder.getSurface() == null) {
// preview surface does not exist
return;
} // stop preview before making changes
try {
mCamera.stopPreview();
} catch (Exception e) {
// ignore: tried to stop a non-existent preview
} try {
Camera.Parameters parameters = mCamera.getParameters(); List<Size> sizes = parameters.getSupportedPreviewSizes();
Size optimalSize = getOptimalPreviewSize(sizes, w, h);
parameters.setPreviewSize(optimalSize.width, optimalSize.height);
double targetRatio = (double) w / h;
sizes = parameters.getSupportedPictureSizes();
optimalSize = getOptimalPictureSize(sizes, targetRatio);
parameters.setPictureSize(optimalSize.width, optimalSize.height);
parameters.setRotation(0);
mCamera.setParameters(parameters);
} catch (Exception e) {
Debug.debug(e.toString());
} // set preview size and make any resize, rotate or
// reformatting changes here // start preview with new settings
try {
mCamera.setPreviewDisplay(mHolder);
mCamera.startPreview();
} catch (Exception e) {
Debug.debug("Error starting camera preview: " + e.getMessage());
}
}
} private int findFrontFacingCamera() {
int cameraId = -1;
// Search for the front facing camera
int numberOfCameras = Camera.getNumberOfCameras();
for (int i = 0; i < numberOfCameras; i++) {
CameraInfo info = new CameraInfo();
Camera.getCameraInfo(i, info);
if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
Log.d(TAG, "Camera found");
cameraId = i;
break;
}
}
return cameraId;
} private static void setCameraDisplayOrientation(Activity activity, int cameraId, Camera camera) {
CameraInfo info = new CameraInfo();
Camera.getCameraInfo(cameraId, info);
int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
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 == 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;
} //LogEx.i("result: " + result);
camera.setDisplayOrientation(result);
} @Override
public void needFocuse() { //LogEx.i("_isCapturing: " + _isCapturing);
if (null == camera || _isCapturing) {
return;
} //LogEx.i("autoFocus");
camera.cancelAutoFocus();
try {
camera.autoFocus(focusCallback);
} catch (Exception e) {
Debug.debug(e.toString());
return;
} if (View.INVISIBLE == focuseView.getVisibility()) {
focuseView.setVisibility(View.VISIBLE);
focuseView.getParent().requestTransparentRegion(preview);
}
} //相机旋转监听的类，最后保存图片时用到
private class CaptureOrientationEventListener extends OrientationEventListener {
public CaptureOrientationEventListener(Context context) {
super(context);
} @Override
public void onOrientationChanged(int orientation) {
if (null == camera)
return;
if (orientation == ORIENTATION_UNKNOWN)
return; orientation = (orientation + 45) / 90 * 90;
if (android.os.Build.VERSION.SDK_INT <= 8) {
_rotation = (90 + orientation) % 360;
return;
} CameraInfo info = new CameraInfo();
Camera.getCameraInfo(currentCameraId, info); if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
_rotation = (info.orientation - orientation + 360) % 360;
} else { // back-facing camera
_rotation = (info.orientation + orientation) % 360;
}
}
}
}