前记：Android这个开源而*的系统，为我们带来开发便利，同时也埋下太多的深坑。例如调用系统自带的相机就会出现照片丢失，或者其他各种各样的问题。因此，看来自定义一个相机十分的必要。
要自定义相机我们无法要利用surfaceview与自带camera两把利器。
首先了解surfaceview的基本含义：
通常情况程序的View和用户响应都是在同一个线程中处理的，这也是为什么处理长时间事件（例如访问网络）需要放到另外的线程中去（防止阻塞当前UI线程的操作和绘制）。但是在其他线程中却不能修改UI元素，例如用后台线程更新自定义View（调用View的在自定义View中的onDraw函数）是不允许的。 如果需要在另外的线程绘制界面、需要迅速的更新界面或则渲染UI界面需要较长的时间，这种情况就要使用SurfaceView了。
SurfaceView中包含一个Surface对象，而Surface是可以在后台线程中绘制的。Surface属于 OPhone底层显示系统。SurfaceView的性质决定了其比较适合一些场景：需要界面迅速更新、对帧率要求较高的情况。使用SurfaceView需要注意以下几点情况： SurfaceView和SurfaceHolder.Callback函数都从当前SurfaceView窗口线程中调用（一般而言就是程序的主线程）。有关资源状态要注意和绘制线程之间的同步。 在绘制线程中必须先合法的获取Surface才能开始绘制内容，在SurfaceHolder.Callback.surfaceCreated() 和SurfaceHolder.Callback.surfaceDestroyed()之间的状态为合法的，另外在Surface类型为SURFACE_TYPE_PUSH_BUFFERS时候是不合法的。 额外的绘制线程会消耗系统的资源，在使用SurfaceView的时候要注意这点。
了解了这么多，我们来开始写我们的相机。首先，需要surfaceview来判断刷新界面。同样surefaceview三要素holder,callback,created.
使用SurfaceView 只要继承SurfaceView类并实现（1）SurfaceHolder.Callback接口就可以实现一个自定义的SurfaceView了，（2）SurfaceHolder.Callback在底层的Surface状态发生变化的时候通知View，SurfaceHolder.Callback具有如下的接口：
（3）surfaceCreated(SurfaceHolder holder)：当Surface第一次创建后会立即调用该函数。程序可以在该函数中做些和绘制界面相关的初始化工作，一般情况下都是在另外的线程来绘制界面，所以不要在这个函数中绘制Surface。
有了这些理论的铺垫，我们所需做的就是在surfaceCreated对camera打开使其聚焦，做好拍照的操作：相应的源码如下：
private void initSurfaceView() {
try {
camera = Camera.open();// 打开硬件摄像头，这里导包得时候一定要注意是android.hardware.Camera
Camera.Parameters parameters = camera.getParameters();// 得到摄像头的参数
int PreviewWidth = 0;
int PreviewHeight = 0;
List<Camera.Size> size_list = parameters.getSupportedPreviewSizes();
if (size_list.size() > 0) {
Iterator<Camera.Size> itor = size_list.iterator();
while (itor.hasNext()) {
Camera.Size cur = itor.next();
if (cur.width >= PreviewWidth
&& cur.height >= PreviewHeight) {
PreviewWidth = cur.width;
PreviewHeight = cur.height;
// break;
}
}
}
WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);// 得到窗口管理器
// Display display = wm.getDefaultDisplay();// 得到当前屏幕
parameters.setPreviewSize(PreviewWidth, PreviewHeight);// 设置预览照片的大小
parameters.setPictureFormat(PixelFormat.JPEG);// 设置照片的格式
parameters.setJpegQuality(100);// 设置照片的质量
System.out.println(camera.getParameters().flatten());
List<Size> picSizeValues = camera.getParameters()
.getSupportedPictureSizes();
if (picSizeValues.get(0).width > picSizeValues.get(picSizeValues
.size() - 1).width) {
for (Size size : picSizeValues) {
Log.v("show", size.width + "\n");
if (size.width <= 1024) {
parameters.setPictureSize(size.width, size.height);// 设置照片的大小，默认是和
break;
}
}
} else {
for (int i = picSizeValues.size() - 1; i >= 0; i -= 1) {
Log.v("show", picSizeValues.get(i).width + "\n");
if (picSizeValues.get(i).width <= 1024) {
parameters.setPictureSize(picSizeValues.get(i).width,
picSizeValues.get(i).height);
break;
}
}
}
parameters.setFlashMode(parameters.FLASH_MODE_AUTO);
// 屏幕一样大
camera.setParameters(parameters);
camera.setPreviewDisplay(surface_view.getHolder());// 通过SurfaceView显示取景画面
camera.startPreview();// 开始预览
is_preview = true;// 设置是否预览参数为真
} catch (IOException e) {
// Log.e(TAG, e.toString());
}
}
通过代码，我们清晰看到了我们利用camera对象，他是何物了？他是Android提供的对摄像头操作的相应的API。我们看到上面的代码，我们设置camera拍摄的范围应该控制宽度在1024以下，并且预览的实在surefaceview范围内。
这样应该简单相机就做出来了。但是，似乎不是那么完美，我们相机似乎差了什么样的，首先要有一个手动聚焦光圈。要完成这个功能，工作量不小啊：首先需要一个focusmanager来管理聚焦的操作：他的内部应该是这样的：
private Camera mCamera;
private static final String TAG="FocusManager";
private static final int FOCUS_WIDTH = 80;
private static final int FOCUS_HEIGHT = 80;
public interface FocusListener {
public void onFocusStart(boolean smallAdjust);
public void onFocusReturns(boolean smallAdjust, boolean success);
}
private int mFocusKeepTimeMs = 3000;
private long mLastFocusTimestamp = 0;
private Handler mHandler;
private FocusListener mListener;
private boolean mIsFocusing;
public final FocusManager mfocusManager;
private Object mParametersSync=new Object();
public FocusManager(Camera mCamera) {
mHandler = new Handler();
mIsFocusing = false;
this.mCamera = mCamera;
mfocusManager=this;
Camera.Parameters params = mCamera.getParameters();
if (params.getSupportedFocusModes().contains("auto")) {
params.setFocusMode("auto");
}
// Do a first focus after 1 second
mHandler.postDelayed(new Runnable() {
public void run() {
checkFocus();
}
}, 1000);
}
public void setListener(FocusListener listener) {
mListener = listener;
}
public void checkFocus() {
long time = System.currentTimeMillis();
if (time - mLastFocusTimestamp > mFocusKeepTimeMs && !mIsFocusing) {
refocus();
} else if (time - mLastFocusTimestamp > mFocusKeepTimeMs * 2) {
// Force a refocus after 2 times focus failed
refocus();
}
}
public void refocus() {
if (doAutofocus(this)) {
mIsFocusing = true;
if (mListener != null) {
mListener.onFocusStart(false);
}
}
}
private boolean doAutofocus(FocusManager focusManager) {
if (mCamera != null) {
try {
// Trigger af
mCamera.cancelAutoFocus();
mHandler.post(new Runnable() {
public void run() {
try {
mCamera.autoFocus(mfocusManager);
} catch (Exception e) {
// Do nothing here
}
}
});
} catch (Exception e) {
return false;
}
return true;
} else {
return false;
}
}
@Override
public void onAutoFocus(boolean success, Camera camera) {
mLastFocusTimestamp = System.currentTimeMillis();
mIsFocusing = false;
if (mListener != null) {
mListener.onFocusReturns(false, success);
}
}
/***
* 最大区域
* @return
*/
@SuppressLint("NewApi")
public boolean isFocusAreaSupported() {
if (mCamera != null) {
try {
return (getParameters().getMaxNumFocusAreas() > 0);
} catch (Exception e) {
return false;
}
} else {
return false;
}
}
private Parameters getParameters() {
Parameters Parameters=null;
synchronized (mParametersSync) {
if (mCamera == null) {
Log.w("", "getParameters when camera is null");
return null;
}
int tries = 0;
while (Parameters == null) {
try {
Parameters = mCamera.getParameters();
break;
} catch (RuntimeException e) {
Log.e(TAG, "Error while getting parameters: ", e);
if (tries < 3) {
tries++;
try {
Thread.sleep(100);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
} else {
Log.e(TAG, "Failed to get parameters after 3 tries");
break;
}
}
}
}
return Parameters;
}
@SuppressLint("NewApi")
public void setFocusPoint(int x, int y) {
if (x < -1000 || x > 1000 || y < -1000 || y > 1000) {
Log.e(TAG, "setFocusPoint: values are not ideal " + "x= " + x + " y= " + y);
return;
}
Camera.Parameters params = getParameters();
if (params != null && params.getMaxNumFocusAreas() > 0) {
List<Camera.Area> focusArea = new ArrayList<Camera.Area>();
focusArea.add(new Camera.Area(new Rect(x, y, x + FOCUS_WIDTH, y + FOCUS_HEIGHT), 1000));
params.setFocusAreas(focusArea);
try {
mCamera.setParameters(params);
} catch (Exception e) {
}
}
}
首先，有一个camera对象，来通知我们来操作那个camera对象的聚焦。
又上而下的来扫描此对象，我们观察操作最多的是对对焦调整。在checkFocus中，在其一定时间范围内使其强制对焦。在refocus这个方法中，用户的自动对焦开始，并且监听相应对焦状态的变化，用以调整对焦光圈的变化。而在isFocusAreaSupported方法中，我们要判断camera对象所支持的参数的聚焦的最大的范围是否大于0。经过这一系列的判断逻辑，我们对camera聚焦有了控制了。
我们接下来要做的就是需要对其对焦的光圈来唠叨唠叨。对焦光圈就是相机聚焦区域来显示了一个光圈：他的类名叫做FocusHudRing。源码如下：
private FocusManager mFocusManager;
public FocusHudRing(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
} public FocusHudRing(Context context, AttributeSet attrs) {
super(context, attrs);
// TODO Auto-generated constructor stub
} public FocusHudRing(Context context) {
super(context);
// TODO Auto-generated constructor stub
} @Override
@SuppressLint("ClickableViewAccessibility")
protected void onFinishInflate() {
// TODO Auto-generated method stub
super.onFinishInflate();
setImage(true);
} public void setImage(boolean success) {
// TODO Auto-generated method stub
if (success) {
setImageResource(R.drawable.hud_focus_ring_success);
} else {
setImageResource(R.drawable.hud_focus_ring_fail);
}
} public void setPosition(float x, float y) {
setX(x - getWidth() / 2.0f);
setY(y - getHeight() / 2.0f);
applyFocusPoint();
} private void applyFocusPoint() {
ViewGroup parent = (ViewGroup) getParent();
if (parent == null) return; // We swap X/Y as we have a landscape preview in portrait mode
float centerPointX = getY() + getHeight() / 2.0f;
float centerPointY = parent.getWidth() - (getX() + getWidth() / 2.0f); centerPointX *= 1000.0f / parent.getHeight();
centerPointY *= 1000.0f / parent.getWidth(); centerPointX = (centerPointX - 500.0f) * 2.0f;
centerPointY = (centerPointY - 500.0f) * 2.0f;
if (mFocusManager != null) {
mFocusManager.setFocusPoint((int) centerPointX, (int) centerPointY);
}
}
public boolean onTouch(View view, MotionEvent motionEvent) {
super.onTouch(view, motionEvent); if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
applyFocusPoint();
if (mFocusManager != null) {
mFocusManager.refocus();
}
}
return true;
} public FocusManager getFocusManager() {
return mFocusManager;
} public void setFocusManager(FocusManager mFocusManager) {
this.mFocusManager = mFocusManager;
}
focushudring又不是简单存在，他又继承与hudring这个自定义控件，用户点击到了某个区域的话，这个控件就会出现在一定区域。就是依靠这个setposition控件，applyfocuspoint就是计算这个圆形，并且开启动画。
有了这两个类以后，一个自定义聚焦控件就做好，你所做的就是监听下屏幕的手势事件，可能我说的不够清楚，大家请看代码吧？代码的位置是：