android 自定義相機Camera2

阿新 • • 發佈：2019-01-13

上一篇文章我們已經運用Camera自定義了一個相機，今天我們就用Camera2自定義一個相機。Camera2是android5.0新增的api，Camera2與Camera差別比較大，採用了全新的模式，功能更加強大。今天這個例子就是Camera2拍照TextureView上面進行預覽，把之前的SurfaceView代替了。

一、開啟攝像頭

1、TextureView設定監聽

//設定TextureView監聽
tv.setSurfaceTextureListener(surfaceTextureListener);

2、在監聽中，可用狀態時開啟攝像頭

/**TextureView的監聽*/
private  
TextureView.SurfaceTextureListener surfaceTextureListener= new TextureView.SurfaceTextureListener() {
    //可用
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        MainActivity.this.width=width;
MainActivity.this.height=height;
openCamera();
}

    @Override
 
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
    }

    //釋放
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        stopCamera();
        return true;
}

    //更新
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
    }
};

3、開啟攝像頭（camera2採用的是CameraManager）

/**開啟攝像頭*/
private void openCamera() {
    CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
//設定攝像頭特性
setCameraCharacteristics(manager);
    try {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            //提示使用者開戶許可權
String[] perms = {"android.permission.CAMERA"};
ActivityCompat.requestPermissions(MainActivity.this,perms, RESULT_CODE_CAMERA);
}else {
            manager.openCamera(mCameraId, stateCallback, null);
}

    } catch (CameraAccessException e){
        e.printStackTrace();
}
}

4、設定攝像頭的一些特性

/**設定攝像頭的引數*/
private void setCameraCharacteristics(CameraManager manager)
{
    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(imageAvailableListener,null);
// 獲取最佳的預覽尺寸
previewSize = chooseOptimalSize(map.getOutputSizes(
                SurfaceTexture.class), width, height, largest);
}
    catch (CameraAccessException e)
    {
        e.printStackTrace();
}
    catch (NullPointerException e)
    {
    }
}
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
{
       //沒有合適的預覽尺寸
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());
}
}

二、進行拍照預覽

1、監聽攝像頭

manager.openCamera(mCameraId, stateCallback, null);

2、在攝像頭開啟是進行畫面的預覽

/**攝像頭狀態的監聽*/
private CameraDevice.StateCallback stateCallback = new CameraDevice. StateCallback()
{
    // 攝像頭被開啟時觸發該方法
@Override
public void onOpened(CameraDevice cameraDevice){
       MainActivity.this.cameraDevice = cameraDevice;
// 開始預覽
takePreview();
}

    // 攝像頭斷開連線時觸發該方法
@Override
public void onDisconnected(CameraDevice cameraDevice)
    {
        MainActivity.this.cameraDevice.close();
MainActivity.this.cameraDevice = null;
}
    // 開啟攝像頭出現錯誤時觸發該方法
@Override
public void onError(CameraDevice cameraDevice, int error)
    {
        cameraDevice.close();
}
};

3、進行預覽的設定和處理

/**
 * 開始預覽
 */
private void takePreview() {
    SurfaceTexture mSurfaceTexture = tv.getSurfaceTexture();
//設定TextureView的緩衝區大小
mSurfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
//獲取Surface顯示預覽資料
Surface mSurface = new Surface(mSurfaceTexture);
    try {
        //建立預覽請求
mCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
// 設定自動對焦模式
mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//設定Surface作為預覽資料的顯示介面
mCaptureRequestBuilder.addTarget(mSurface);
//建立相機捕獲會話，第一個引數是捕獲資料的輸出Surface列表，第二個引數是CameraCaptureSession的狀態回撥介面，當它建立好後會回撥onConfigured方法，第三個引數用來確定Callback在哪個執行緒執行，為null的話就在當前執行緒執行
cameraDevice.createCaptureSession(Arrays.asList(mSurface,imageReader.getSurface()),new CameraCaptureSession.StateCallback() {
            @Override
public void onConfigured(CameraCaptureSession session) {
                try {
                    //開始預覽
mCaptureRequest = mCaptureRequestBuilder.build();
mPreviewSession = session;
//設定反覆捕獲資料的請求，這樣預覽介面就會一直有資料顯示
mPreviewSession.setRepeatingRequest(mCaptureRequest, null, null);
} catch (CameraAccessException e) {
                    e.printStackTrace();
}

            }

            @Override
public void onConfigureFailed(CameraCaptureSession session) {

            }
        }, null);
} catch (CameraAccessException e) {
        e.printStackTrace();
}

}

三、拍照

1、進行拍照的處理和設定

/**拍照*/
private void takePicture()
{
    try
{
        if (cameraDevice == null)
        {
            return;
}
        // 建立拍照請求
captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
// 設定自動對焦模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// 將imageReader的surface設為目標
captureRequestBuilder.addTarget(imageReader.getSurface());
// 獲取裝置方向
int rotation = getWindowManager().getDefaultDisplay().getRotation();
// 根據裝置方向計算設定照片的方向
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION
, ORIENTATIONS.get(rotation));
// 停止連續取景
mPreviewSession.stopRepeating();
//拍照
CaptureRequest captureRequest = captureRequestBuilder.build();
//設定拍照監聽
mPreviewSession.capture(captureRequest,captureCallback, null);
}
    catch (CameraAccessException e)
    {
        e.printStackTrace();
}

2、監聽拍照結果（成功後恢復預覽）

/**監聽拍照結果*/
private CameraCaptureSession.CaptureCallback captureCallback= new CameraCaptureSession.CaptureCallback()
{
    // 拍照成功
@Override
public void onCaptureCompleted(CameraCaptureSession session,CaptureRequest request,TotalCaptureResult result)
    {
        // 重設自動對焦模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
// 設定自動曝光模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
        try {
            //重新進行預覽
mPreviewSession.setRepeatingRequest(mCaptureRequest, null, null);
} catch (CameraAccessException e) {
            e.printStackTrace();
}

    }

    @Override
public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
        super.onCaptureFailed(session, request, failure);
}
};

四、拍照的圖片儲存到本地相簿（用的是ImageReader進行接收圖片）

/**監聽拍照的圖片*/
private ImageReader.OnImageAvailableListener imageAvailableListener= new ImageReader.OnImageAvailableListener()
{
    // 當照片資料可用時激發該方法
@Override
public void onImageAvailable(ImageReader reader) {

        //先驗證手機是否有sdcard
String status = Environment.getExternalStorageState();
        if (!status.equals(Environment.MEDIA_MOUNTED)) {
            Toast.makeText(getApplicationContext(), "你的sd卡不可用。", Toast.LENGTH_SHORT).show();
            return;
}
        // 獲取捕獲的照片資料
Image image = reader.acquireNextImage();
ByteBuffer buffer = image.getPlanes()[0].getBuffer();
        byte[] data = new byte[buffer.remaining()];
buffer.get(data);
//手機拍照都是存到這個路徑
String filePath = Environment.getExternalStorageDirectory().getPath() + "/DCIM/Camera/";
String picturePath = System.currentTimeMillis() + ".jpg";
File file = new File(filePath, picturePath);
        try {
            //存到本地相簿
FileOutputStream fileOutputStream = new FileOutputStream(file);
fileOutputStream.write(data);
fileOutputStream.close();
//顯示圖片
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
iv.setImageBitmap(bitmap);
} catch (FileNotFoundException e) {
            e.printStackTrace();
} catch (IOException e) {
            e.printStackTrace();
} finally {
            image.close();
}
    }


};

五、完整的程式碼

1、activity程式碼

package com.sunshanglei.camera.oneselfcamera;
import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
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.CaptureFailure;
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.Environment;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Size;
import android.util.SparseIntArray;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
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;
/**
 * use 自定義相機Camera2
 * author 孫尚磊
 * create time 2017-4-25
 */
public class MainActivity extends AppCompatActivity{
    private TextureView tv;
    private Button btn;
    private String mCameraId = "0";//攝像頭id（通常0代表後置攝像頭，1代表前置攝像頭）
private final int RESULT_CODE_CAMERA=1;//判斷是否有拍照許可權的標識碼
private CameraDevice cameraDevice;
    private CameraCaptureSession mPreviewSession;
    private CaptureRequest.Builder mCaptureRequestBuilder,captureRequestBuilder;
    private CaptureRequest mCaptureRequest;
    private ImageReader imageReader;
    private int height=0,width=0;
    private Size previewSize;
    private ImageView iv;
    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);
}

    @Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv = (TextureView) findViewById(R.id.tv);
btn = (Button) findViewById(R.id.btn);
iv= (ImageView) findViewById(R.id.iv);
//拍照
btn.setOnClickListener(new View.OnClickListener() {
            @Override
public void onClick(View v) {
                takePicture();
}
        });
//設定TextureView監聽
tv.setSurfaceTextureListener(surfaceTextureListener);
}

    @Override
protected void onPause() {
        super.onPause();
        if(cameraDevice!=null) {
            stopCamera();
}
    }

    @Override
protected void onResume() {
        super.onResume();
startCamera();
}

    /**TextureView的監聽*/
private TextureView.SurfaceTextureListener surfaceTextureListener= new TextureView.SurfaceTextureListener() {

        //可用
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
            MainActivity.this.width=width;
MainActivity.this.height=height;
openCamera();
}


        @Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {

        }

        //釋放
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
            stopCamera();
            return true;
}

        //更新
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {

        }
    };
/**開啟攝像頭*/
private void openCamera() {
        CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
//設定攝像頭特性
setCameraCharacteristics(manager);
        try {
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                //提示使用者開戶許可權
String[] perms = {"android.permission.CAMERA"};
ActivityCompat.requestPermissions(MainActivity.this,perms, RESULT_CODE_CAMERA);
}else {
                manager.openCamera(mCameraId, stateCallback, null);
}

        } catch (CameraAccessException e){
            e.printStackTrace();
}
    }


    /**設定攝像頭的引數*/
private void setCameraCharacteristics(CameraManager manager)
    {
        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(imageAvailableListener,null);
// 獲取最佳的預覽尺寸
previewSize = chooseOptimalSize(map.getOutputSizes(
                    SurfaceTexture.class), width, height, largest);
}
        catch (CameraAccessException e)
        {
            e.printStackTrace();
}
        catch (NullPointerException e)
        {
        }
    }
    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
{
           //沒有合適的預覽尺寸
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());
}
    }



    /**攝像頭狀態的監聽*/
private CameraDevice.StateCallback stateCallback = new CameraDevice. StateCallback()
    {
        // 攝像頭被開啟時觸發該方法
@Override
public void onOpened(CameraDevice cameraDevice){
           MainActivity.this.cameraDevice = cameraDevice;
// 開始預覽
takePreview();
}

        // 攝像頭斷開連線時觸發該方法
@Override
public void onDisconnected(CameraDevice cameraDevice)
        {
            MainActivity.this.cameraDevice.close();
MainActivity.this.cameraDevice = null;
}
        // 開啟攝像頭出現錯誤時觸發該方法
@Override
public void onError(CameraDevice cameraDevice, int error)
        {
            cameraDevice.close();
}
    };
/**
     * 開始預覽
     */
private void takePreview() {
        SurfaceTexture mSurfaceTexture = tv.getSurfaceTexture();
//設定TextureView的緩衝區大小
mSurfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
//獲取Surface顯示預覽資料
Surface mSurface = new Surface(mSurfaceTexture);
        try {
            //建立預覽請求
mCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
// 設定自動對焦模式
mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
//設定Surface作為預覽資料的顯示介面
mCaptureRequestBuilder.addTarget(mSurface);
//建立相機捕獲會話，第一個引數是捕獲資料的輸出Surface列表，第二個引數是CameraCaptureSession的狀態回撥介面，當它建立好後會回撥onConfigured方法，第三個引數用來確定Callback在哪個執行緒執行，為null的話就在當前執行緒執行
cameraDevice.createCaptureSession(Arrays.asList(mSurface,imageReader.getSurface()),new CameraCaptureSession.StateCallback() {
                @Override
public void onConfigured(CameraCaptureSession session) {
                    try {
                        //開始預覽
mCaptureRequest = mCaptureRequestBuilder.build();
mPreviewSession = session;
//設定反覆捕獲資料的請求，這樣預覽介面就會一直有資料顯示
mPreviewSession.setRepeatingRequest(mCaptureRequest, null, null);
} catch (CameraAccessException e) {
                        e.printStackTrace();
}

                }

                @Override
public void onConfigureFailed(CameraCaptureSession session) {

                }
            }, null);
} catch (CameraAccessException e) {
            e.printStackTrace();
}

    }


    /**拍照*/
private void takePicture()
    {
        try
{
            if (cameraDevice == null)
            {
                return;
}
            // 建立拍照請求
captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
// 設定自動對焦模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// 將imageReader的surface設為目標
captureRequestBuilder.addTarget(imageReader.getSurface());
// 獲取裝置方向
int rotation = getWindowManager().getDefaultDisplay().getRotation();
// 根據裝置方向計算設定照片的方向
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION
, ORIENTATIONS.get(rotation));
// 停止連續取景
mPreviewSession.stopRepeating();
//拍照
CaptureRequest captureRequest = captureRequestBuilder.build();
//設定拍照監聽
mPreviewSession.capture(captureRequest,captureCallback, null);
}
        catch (CameraAccessException e)
        {
            e.printStackTrace();
}
    }

    /**監聽拍照結果*/
private CameraCaptureSession.CaptureCallback captureCallback= new CameraCaptureSession.CaptureCallback()
    {
        // 拍照成功
@Override
public void onCaptureCompleted(CameraCaptureSession session,CaptureRequest request,TotalCaptureResult result)
        {
            // 重設自動對焦模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
// 設定自動曝光模式
captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
            try {
                //重新進行預覽
mPreviewSession.setRepeatingRequest(mCaptureRequest, null, null);
} catch (CameraAccessException e) {
                e.printStackTrace();
}

        }

        @Override
public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
            super.onCaptureFailed(session, request, failure);
}
    };
/**監聽拍照的圖片*/
private ImageReader.OnImageAvailableListener imageAvailableListener= new ImageReader.OnImageAvailableListener()
    {
        // 當照片資料可用時激發該方法
@Override
public void onImageAvailable(ImageReader reader) {

            //先驗證手機是否有sdcard
String status = Environment.getExternalStorageState();
            if (!status.equals(Environment.MEDIA_MOUNTED)) {
                Toast.makeText(getApplicationContext(), "你的sd卡不可用。", Toast.LENGTH_SHORT).show();
                return;
}
            // 獲取捕獲的照片資料
Image image = reader.acquireNextImage();
ByteBuffer buffer = image.getPlanes()[0].getBuffer();
            byte[] data = new byte[buffer.remaining()];
buffer.get(data);
//手機拍照都是存到這個路徑
String filePath = Environment.getExternalStorageDirectory().getPath() + "/DCIM/Camera/";
String picturePath = System.currentTimeMillis() + ".jpg";
File file = new File(filePath, picturePath);
            try {
                //存到本地相簿
FileOutputStream fileOutputStream = new FileOutputStream(file);
fileOutputStream.write(data);
fileOutputStream.close();
//顯示圖片
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
iv.setImageBitmap(bitmap);
} catch (FileNotFoundException e) {
                e.printStackTrace();
} catch (IOException e) {
                e.printStackTrace();
} finally {
                image.close();
}
        }


    };
@Override
public void onRequestPermissionsResult(int permsRequestCode, String[] permissions, int[] grantResults){
        switch(permsRequestCode){
            case RESULT_CODE_CAMERA:
                boolean cameraAccepted = grantResults[0]==PackageManager.PERMISSION_GRANTED;
                if(cameraAccepted){
                    //授權成功之後，呼叫系統相機進行拍照操作等
openCamera();
}else{
                    //使用者授權拒絕之後，友情提示一下就可以了
Toast.makeText(MainActivity.this,"請開啟應用拍照許可權",Toast.LENGTH_SHORT).show();
}
                break;
}
    }

    /**啟動拍照*/
private void startCamera(){
        if (tv.isAvailable()) {
            if(cameraDevice==null) {
                openCamera();
}
        } else {
            tv.setSurfaceTextureListener(surfaceTextureListener);
}
    }

    /**
     * 停止拍照釋放資源*/
private void stopCamera(){
        if(cameraDevice!=null){
            cameraDevice.close();
cameraDevice=null;
}

    }
}

2、xml程式碼

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
    <TextureView
android:id="@+id/tv"
android:layout_above="@+id/ll_bottom"
android:layout_width=<

android 自定義相機Camera2

上一篇文章我們已經運用Camera自定義了一個相機，今天我們就用Camera2自定義一個相機。Camera2是android5.0新增的api，Camera2與Camera差別比較大，採用了全新的模式，功能更加強大。今天這個例子就是Camera2拍照TextureView

Android自定義相機超詳細講解

了解 catch 實現 4.4 required form 需要 eset 自己 Android自定義相機超詳細講解轉載請標明出處： http://blog.csdn.net/vinicolor/article/details/49642861；由於網上關於Andr

Android 自定義相機 Camera 圖片方向問題

相機預覽方向問題對於相機的預覽方向我們可以通過如下API進行設定 camera.setDisplayOrientation(0);但是，該API影響的是相機的預覽方向，對於照片的儲存方向並沒有什麼影響，最終照片儲存的方向還是由Camera的影象Sensor決定的。照片儲

Android自定義相機Camera（一）

Time：2018/06/21 因為專案需求，需要實現跟小猿搜題的類似的功能，系統相機直接就被排除了，原本打算是找個一個demo，改吧改吧就直接用了，找的過程中發現程式碼太舊了，目前6.0以上的系統很多不支援，然後按照demo的邏輯，就寫一個相

android自定義相機（帶邊框和按鈕）

前兩個月專案要求不能呼叫系統的相機，那就只能用自定義的了，查了一些資料，自己再研究了一下，自定義的相機還是有點複雜的，佈局和程式碼中都要用到一個重要的SurfaceView。一、建立佈局，佈局的背景框可以讓美工給出，這裡姑且就是一個藍色的邊框，然後下面有三個按鈕，我里布局檔案activit

Android 自定義相機第二次開啟卡死

原因：相機沒有被正確釋放導致第二次打卡死。 //正確的釋放資原始碼 public void release(){ if (mCamera != null) { mCamera.setPreviewCallback(null) ;

Android 自定義相機Demo 入門學習

Android 自定義相機Demo 本文是參考網上一些自定義相機示例，再結合自己對相機的功能需求寫的，基本上包含了很多基本功能，比如相機對焦、閃光燈，以及在手機預覽介面上繪製自己想要繪製的圖案。話不多說，先上一張圖：應用是在Android Studio中開發的，java程

Android自定義相機實現N連拍

/** * 描述：自動連續拍照 * 開發者：開發者的樂趣JRT * 建立時間：2017-3-15 19:16 * CSDN地址：http://blog.csdn.net/Jiang_Rong_Tao/article * E-mail：[email protected] **/ publi

Android 自定義相機

Camera 相信大家對相機的使用都不陌生吧，下面我給大家分享一下自定義相機 Android提供了Camera來控制拍照，步驟如下：（1）呼叫Camera的open()方法開啟相機。（2）呼叫Camera的getParameters（）獲取

Android自定義相機預覽開始時自動對焦

如果是呼叫系統相機不會存在對焦問題，要實現自己的相機在開始的時候自動自動對焦，只需要新增兩句程式碼： parameters.setFocusMode(Camera.Paramet

簡單談談android自定義相機的實現（上 android.hardware.Camera）

通常情況下，呼叫android系統相機基本上可以滿足拍照的需求，而自定義相機的需求一般來自於開發自己的相機應用，今天我們來簡單聊聊android自定義相機的實現，限於篇幅，我們上篇只討論android.hardware.Camera，下篇我會和大家一起討論一下a

Android自定義相機拍攝黑屏

速記，備查。 1、需求場景拍攝20秒 + 視訊質量不能太低 + 視訊大小不能超過5M； 2、方案呼叫系統相機和自定義相機； 1、呼叫系統相機（不滿足需求）視訊質量只能設定高（1）和低（0），高的話，拍出來的視訊太大；低的話，拍出來的視訊大小滿足，但是質量慘不忍睹；而且

Android自定義相機拍的照片不清楚解決方案

最近做一個專案要用到自定義相機，預覽的時候挺清晰的，但是拍好之後就變模糊了，弄了大半天才解決。相機照片的尺寸只有幾種固定的，2592×1936，2048×1536，1600×1200，1024×768，320×240等，這些尺寸還要物理裝置支援才有。設定照片的尺寸（當然要

android 自定義相機旋轉問題解決及照片自動旋轉問題解決

//自動旋轉180情況下 myCamera = Camera.open(); myCamera .setDisplayOrientation(180); //圖片旋轉180情況下解決方法 par

Android自定義相機（三） —— 錄影

前面我們已經大致完成了自定義相機的拍照功能，接下來，我們來實現一下錄影的功能。 1、錄影功能簡介錄影功能的是相對比較簡單，因為步驟是很固定的，google給我們提供的api文件中說的也比較詳細，這裡我們主要用到 MediaRecorder 這個類。

android 自定義相機Camera

專案中，有時系統的相機不能滿足我們的需求，例如：實現美圖，這樣就需要我們進行自定義相機，滿足我們的特殊需求。Android給我們提供了Camera API，可以進行相機的私人訂製。在Android5以後有提供了Camera2 API，廢除了Camera API。但Camera

Android自定義相機實現拍照、預覽、顯示、上傳

自定義相機拍照並存放到本地，可以預覽，用okHttp上傳到伺服器用法 1.點選登入進入到拍照頁面 2.拍照後進入到上傳介面，需要在Constant中修改BASE_URL為自己伺服器圖片上傳地

Android 自定義相機獲取照片（螢幕適配）

1.在應用程式中自定義相機拍照的大體步驟如下： 1.檢測和訪問相機：檢測裝置是否支援拍照，然後發出訪問裝置相機請求。 2.建立一個預覽類：建立一個繼承自類SurfaceView和實現介面SurfaceHolder介面的相機預覽類，這個類用來預覽從相機得到

android自定義相機、連續（自動）聚焦、點選（觸控）聚焦、變焦、拍照後自定義裁剪、旋轉

最近做了一個圖片識別、以及搜尋的小專案，其中有一個模組是拍照以及拍照後對圖片進行剪下，開始用的系統的相機和裁剪，由於系統的相機和裁剪多出了一些不必要的步驟和啟動慢等等帶給使用者的體驗不好，故自己寫了一個，下面給大家簡要介紹下：自定義相機：定義SurfaceView得到Su

Android自定義相機，帶邊框截圖

專案需求：要實現自定義拍照介面，並且只取框框中的內容。問題點：1、通過Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)方式自動對焦，沒有實現觸控對焦 2、myParameters.setPreview

android 自定義相機Camera2

相關推薦