現在的手機一般都會提供相機功能，有些相機的鏡頭甚至支持1000萬以上像素，有些甚至支持光學變焦，這些手機已經變成了專業數碼相機。爲了充分利用手機上的相機功能，Android應用可以控制拍照和錄製視頻。
使用Android 5.0的Camera v2拍照
Android 5.0對拍照API進行了全新的設計，新增了全新設計的Camera
v2 API，這些API不僅大幅提高了Android系統拍照的功能，還能支持RAW照片輸出，甚至允許程序調整相機的對焦模式、曝光模式、快門等。
Android 5.0的Camera v2主要涉及如下API。
Ø
CameraManager：攝像頭管理器。這是一個全新的系統管理器，專門用於檢測系統攝像頭、打開系統攝像頭。除此之外，調用CameraManager的getCameraCharacteristics(String)方法即可獲取指定攝像頭的相關特性。
Ø
CameraCharacteristics：攝像頭特性。該對象通過CameraManager來獲取，用於描述特定攝像頭所支持的各種特性。
Ø
CameraDevice：代表系統攝像頭。該類的功能類似於早期的Camera類。
Ø
CameraCaptureSession：這是一個非常重要的API，當程序需要預覽、拍照時，都需要先通過該類的實例創建Session。而且不管預覽還是拍照，也都是由該對象的方法進行控制的，其中控制預覽的方法爲setRepeatingRequest()；控制拍照的方法爲capture()。
爲了監聽CameraCaptureSession的創建過程，以及監聽CameraCaptureSession的拍照過程，Camera
v2 API爲CameraCaptureSession提供了StateCallback、CaptureCallback等內部類。
Ø
CameraRequest和CameraRequest.Builder：當程序調用setRepeatingRequest()方法進行預覽時，或調用capture()方法進行拍照時，都需要傳入CameraRequest參數。CameraRequest代表了一次捕獲請求，用於描述捕獲圖片的各種參數設置，比如對焦模式、曝光模式……總之，程序需要對照片所做的各種控制，都通過CameraRequest參數進行設置。CameraRequest.Builder則負責生成CameraRequest對象。
理解了上面API的功能和作用之後，接下來即可使用Camera v2 API來控制攝像頭拍照了。控制拍照的步驟大致如下。
調用CameraManager的openCamera(String
cameraId, CameraDevice.StateCallback callback, Handler handler)方法打開指定攝像頭。該方法的第一個參數代表要打開的攝像頭ID；第二個參數用於監聽攝像頭的狀態；第三個參數代表執行callback的Handler，如果程序希望直接在當前線程中執行callback，則可將handler參數設爲null。
當攝像頭被打開之後，程序即可獲取CameraDevice—即根據攝像頭ID獲取了指定攝像頭設備，然後調用CameraDevice的createCaptureSession(List<Surface>
outputs, CameraCaptureSession. StateCallback callback，Handler handler)方法來創建CameraCaptureSession。該方法的第一個參數是一個List集合，封裝了所有需要從該攝像頭獲取圖片的Surface，第二個參數用於監聽CameraCaptureSession的創建過程；第三個參數代表執行callback的Handler，如果程序希望直接在當前線程中執行callback，則可將handler參數設爲null。
不管預覽還是拍照，程序都調用CameraDevice的createCaptureRequest(int
templateType)方法創建CaptureRequest.Builder，該方法支持TEMPLATE_PREVIEW（預覽）、TEMPLATE_RECORD（拍攝視頻）、TEMPLATE_STILL_CAPTURE（拍照）等參數。
通過第3步所調用方法返回的CaptureRequest.Builder設置拍照的各種參數，比如對焦模式、曝光模式等。
調用CaptureRequest.Builder的build()方法即可得到CaptureRequest對象，接下來程序可通過CameraCaptureSession的setRepeatingRequest()方法開始預覽，或調用capture()方法拍照。
實例：拍照時自動對焦本實例示範了使用Camera v2來進行拍照。當用戶按下拍照鍵時，該應用會自動對焦，當對焦成功時拍下照片。該程序的界面中提供了一個自定義TextureView來顯示預覽取景，十分簡單。該自定義TextureView類的代碼如下。
程序清單：codes\11\3\CameraV2Test\app\src\main\java\org\crazyit\media\MainActivity.java
public class AutoFitTextureView extends TextureView
{
private int mRatioWidth = 0;
private int mRatioHeight = 0;
public AutoFitTextureView(Context context, AttributeSet attrs)
{
super(context, attrs);
}
public void setAspectRatio(int width, int height)
{
mRatioWidth = width;
mRatioHeight = height;
requestLayout();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
if (0 == mRatioWidth || 0 == mRatioHeight)
{
setMeasuredDimension(width, height);
}
else
{
if (width < height * mRatioWidth / mRatioHeight)
{
setMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
}
else
{
setMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
}
}
}
}
接下來的MainActivity將會使用CameraManager來打開CameraDevice，並通過CameraDevice創建CameraCaptureSession，然後即可通過CameraCaptureSession進行預覽或拍照了。該Activity的代碼如下。
程序清單：codes\11\3\CameraV2Test\app\src\main\java\org\crazyit\media\MainActivity.java
public class MainActivity extends Activity implements View.OnClickListener
{
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 AutoFitTextureView textureView;
//
攝像頭ID（通常0代表後置攝像頭，1代表前置攝像頭）
private String mCameraId = "0";
//
定義代表攝像頭的成員變量
private CameraDevice cameraDevice;
//
預覽尺寸
private Size previewSize;
private CaptureRequest.Builder previewRequestBuilder;
//
定義用於預覽照片的捕獲請求
private CaptureRequest previewRequest;
//
定義CameraCaptureSession成員變量
private CameraCaptureSession captureSession;
private ImageReader imageReader;
private final TextureView.SurfaceTextureListener mSurfaceTextureListener
= new TextureView.SurfaceTextureListener()
{
@Override
public void onSurfaceTextureAvailable(SurfaceTexture texture
, int width, int height)
{
//
當TextureView可用時，打開攝像頭
openCamera(width, height);
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture texture
, int width, int height){ }
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) { return true; }
@Override
public void onSurfaceTextureUpdated(SurfaceTexture texture){}
};
private final CameraDevice.StateCallback stateCallback = new CameraDevice. StateCallback()
{
//
攝像頭被打開時激發該方法
@Override
public void onOpened(CameraDevice cameraDevice)
{
MainActivity.this.cameraDevice = cameraDevice;
//
開始預覽
createCameraPreviewSession(); //
②
}
//
攝像頭斷開連接時激發該方法
@Override
public void onDisconnected(CameraDevice cameraDevice)
{
cameraDevice.close();
MainActivity.this.cameraDevice = null;
}
//
打開攝像頭出現錯誤時激發該方法
@Override
public void onError(CameraDevice cameraDevice, int error)
{
cameraDevice.close();
MainActivity.this.cameraDevice = null;
MainActivity.this.finish();
}
};
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
textureView = (AutoFitTextureView) findViewById(R.id.texture);
//
爲該組件設置監聽器
textureView.setSurfaceTextureListener(mSurfaceTextureListener);
findViewById(R.id.capture).setOnClickListener(this);
}
@Override
public void onClick(View view)
{
captureStillPicture();
}
private void captureStillPicture()
{
try
{
if (cameraDevice == null)
{
return;
}
//
創建作爲拍照的CaptureRequest.Builder
final CaptureRequest.Builder captureRequestBuilder = cameraDevice
.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
//
將imageReader的surface作爲CaptureRequest.Builder的目標
captureRequestBuilder.addTarget(imageReader.getSurface());
//
設置自動對焦模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//
設置自動曝光模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
//
獲取設備方向
int rotation = getWindowManager().getDefaultDisplay().getRotation();
//
根據設備方向計算設置照片的方向
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION
, ORIENTATIONS.get(rotation));
//
停止連續取景
captureSession.stopRepeating();
//
捕獲靜態圖像
captureSession.capture(captureRequestBuilder.build()
, new CameraCaptureSession.CaptureCallback() //
⑤
{
//
拍照完成時激發該方法
@Override
public void onCaptureCompleted(CameraCaptureSession session
, CaptureRequest request, TotalCaptureResult result)
{
try
{
//
重設自動對焦模式
previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
//
設置自動曝光模式
previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
//
打開連續取景模式
captureSession.setRepeatingRequest(previewRequest, null, null);
}
catch (CameraAccessException e)
{
e.printStackTrace();
}
}
}, null);
}
catch (CameraAccessException e)
{
e.printStackTrace();
}
}
//
打開攝像頭
private void openCamera(int width, int height)
{
setUpCameraOutputs(width, height);
CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_ SERVICE);
try
{
//
打開攝像頭
manager.openCamera(mCameraId, stateCallback, null); //
①
}
catch (CameraAccessException e)
{
e.printStackTrace();
}
}
private void createCameraPreviewSession()
{
try
{
SurfaceTexture texture = textureView.getSurfaceTexture();
texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
//
創建作爲預覽的CaptureRequest.Builder
previewRequestBuilder = cameraDevice
.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
//
將textureView的surface作爲CaptureRequest.Builder的目標
previewRequestBuilder.addTarget(new Surface(texture));
//
創建CameraCaptureSession，該對象負責管理處理預覽請求和拍照請求
cameraDevice.createCaptureSession(Arrays.asList(surface
, imageReader.getSurface()), new CameraCaptureSession.StateCallback() //
③
{
@Override
public void onConfigured(CameraCaptureSession cameraCaptureSession)
{
//
如果攝像頭爲null，直接結束方法
if (null == cameraDevice)
{
return;
}
//
當攝像頭已經準備好時，開始顯示預覽
captureSession = cameraCaptureSession;
try
{
//
設置自動對焦模式
previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//
設置自動曝光模式
previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
//
開始顯示相機預覽
previewRequest = previewRequestBuilder.build();
//
設置預覽時連續捕獲圖像數據
captureSession.setRepeatingRequest(previewRequest,
null, null); //
④
}
catch (CameraAccessException e)
{
e.printStackTrace();
}
}
@Override
public void onConfigureFailed(CameraCaptureSession cameraCaptureSession)
{
Toast.makeText(MainActivity.this, "配置失敗！"
, Toast.LENGTH_SHORT).show();
}
}, null
);
}
catch (CameraAccessException e)
{
e.printStackTrace();
}
}
private void setUpCameraOutputs(int width, int height)
{
CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_ SERVICE);
try
{
//
獲取指定攝像頭的特性
CameraCharacteristics characteristics
= manager.getCameraCharacteristics(mCameraId);
//
獲取攝像頭支持的配置屬性
StreamConfigurationMap map = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
//
獲取攝像頭支持的最大尺寸
Size largest = Collections.max(
Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)),
new CompareSizesByArea());
//
創建一個ImageReader對象，用於獲取攝像頭的圖像數據
imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(),
ImageFormat.JPEG, 2);
imageReader.setOnImageAvailableListener(
new ImageReader.OnImageAvailableListener()
{
//
當照片數據可用時激發該方法
@Override
public void onImageAvailable(ImageReader reader)
{
//
獲取捕獲的照片數據
Image image = reader.acquireNextImage();
ByteBuffer buffer = image.getPlanes()[0].getBuffer();
byte[] bytes = new byte[buffer.remaining()];
//
使用IO流將照片寫入指定文件
File file = new File(getExternalFilesDir(null), "pic.jpg");
buffer.get(bytes);
try (
FileOutputStream output = new FileOutputStream(file))
{
output.write(bytes);
Toast.makeText(MainActivity.this, "保存: "
+ file, Toast.LENGTH_SHORT).show();
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
image.close();
}
}
}, null);
//
獲取最佳的預覽尺寸
previewSize = chooseOptimalSize(map.getOutputSizes(
SurfaceTexture.class), width, height, largest);
//
根據選中的預覽尺寸來調整預覽組件（TextureView）的長寬比
int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_LANDSCAPE)
{
textureView.setAspectRatio(previewSize.getWidth(), previewSize.
getHeight());
}
else
{
textureView.setAspectRatio(previewSize.getHeight(),
previewSize.getWidth());
}
}
catch (CameraAccessException e)
{
e.printStackTrace();
}
catch (NullPointerException e)
{
System.out.println("出現錯誤。");
}
}
private static Size chooseOptimalSize(Size[] choices
, int width, int height, Size aspectRatio)
{
//
收集攝像頭支持的大過預覽Surface的分辨率
List<Size> bigEnough = new ArrayList<>();
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);
}
}
//
如果找到多個預覽尺寸，獲取其中面積最小的
if (bigEnough.size() > 0)
{
return Collections.min(bigEnough, new CompareSizesByArea());
}
else
{
System.out.println("找不到合適的預覽尺寸！！！");
return choices[0];
}
}
//
爲Size定義一個比較器Comparator
static class CompareSizesByArea implements Comparator<Size>
{
@Override
public int compare(Size lhs, Size rhs)
{
//
強轉爲long保證不會發生溢出
return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
(long) rhs.getWidth() * rhs.getHeight());
}
}
}
上面程序中的①號粗體字代碼用於打開系統攝像頭，openCamera()方法的第一個參數代表請求打開的攝像頭ID，此處傳入的攝像頭ID爲"0"，這代表打開設備後置攝像頭；如果需要打開設備指定攝像頭（比如前置攝像頭），可以在調用openCamera()方法時傳入相應的攝像頭ID。
CameraManager提供了getCameraIdList()方法來獲取設備的攝像頭列表，還提供了getCameraCharacteristics(String
cameraId)方法來獲取指定攝像頭的特性。例如如下代碼：
//
獲取設備上攝像頭列表
String[] ids = CameraManager.getCameraIdList();
//
創建一個空的CameraInfo對象，用於獲取攝像頭信息
Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
for ( String id : ids)
{
CameraCharacteristics cc = getCameraCharacteristics(id);
//
接下來的代碼就可以通過cc來獲取該攝像頭的特性了
...
}
上面程序中的①號粗體字代碼打開後置攝像頭時傳入了一個stateCallback參數，該參數代表的對象可檢測攝像頭的狀態改變，當攝像頭的狀態發生改變時，程序將會自動回調該對象的相應方法。該程序的關鍵是重寫了stateCallback的onOpened(CameraDevice
cameraDevice)方法—當攝像頭被打開時將會自動激發該方法，通過該方法的參數即可讓程序獲取被打開的攝像頭設備。除此之外，程序在onOpened()方法的②號粗體字代碼處調用createCameraPreviewSession()方法創建了CameraCaptureSession，並開始預覽取景。
createCameraPreviewSession()方法中的③號粗體字代碼調用了CameraDevice的createCaptureSession()方法來創建CameraCaptureSession，調用該方法時也傳入了一個CameraCaptureSession.StateCallback參數，這樣即可保證當CameraCaptureSession被創建成功之後立即開始預覽。
createCameraPreviewSession()方法的第一行粗體字代碼將texture組件添加爲previewRequestBuilder的target，這意味着程序通過previewRequestBuilder獲取的圖像數據將會被顯示在texture組件上。
程序重寫了CameraCaptureSession.StateCallback的onConfigured()方法—當CameraCaptureSession創建成功時將會自動回調該方法，該方法先通過previewRequestBuilder設置了預覽參數，然後調用CameraCaptureSession對象的setRepeatingRequest()方法開始預覽。
當單擊程序界面上的拍照按鈕時，程序將會激發該Activity的captureStillPicture()方法。該方法的實現邏輯同樣很簡單：程序先創建一個CaptureRequest.Builder對象，該方法中第一行粗體字代碼將ImageReader添加成CaptureRequest.Builder的target—這意味着當程序拍照時，圖像數據將會被傳給此ImageReader。接下來程序通過CaptureRequest.Builder設置了拍照參數，然後通過⑤號粗體字代碼調用CameraCaptureSession的capture()方法拍照即可，調用該方法時也傳入了CaptureCallback參數，這樣可以保證拍照完成之後會重新開始預覽。
注意：該應用打開攝像頭、創建CameraCaptureSession、預覽、拍照時都沒有傳入Handler參數，這意味着程序直接在主線程中完成相應的Callback任務，這樣可能導致程序響應變慢。對於實際的應用，我們建議傳入Handler參數，這樣即可讓Handler使用新線程來執行Callback任務，這樣纔可提高應用的響應速度。
由於該程序需要使用手機的攝像頭，因此還需要在AndroidManifest.xml文件中增加如下配置：
<!--
授予該程序使用攝像頭的權限 -->
<uses-permission android:name="android.permission.CAMERA" />
在Genymotion模擬器上運行該程序可能看到如圖1所示的預覽界面—這是因爲Genymotion模擬器可以使用宿主電腦上的攝像頭作爲相機攝像頭。
爲了讓模擬器能顯示圖1所示的預覽界面，建議讀者啓用Genymotion模擬器的攝像頭支持：單擊Genymotion模擬器右邊的攝像頭圖標，即可看到如圖2所示的對話框。按該圖上標出的提示即可打開Genymotion模擬器的攝像頭支持。
運行該程序，按下右下角的“拍照”鍵，程序將會把拍得的照片保存下來，界面上也會顯示該照片的存儲目錄。
