camera open流程

1、Java 层

• frameworks/base/core/java/android/hardware/camera2/CameraManager.java
• frameworks/base/core/java/android/hardware/camera2/impl/CameraDeviceImpl.java

/* CameraManager.java */
public void openCamera(@NonNull String cameraId,
        @NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)
        throws CameraAccessException {
   
    openCameraForUid(cameraId, callback, handler, USE_CALLING_UID);
}
/*最初的入口就是CameraManager的openCamera方法，通过代码可以看到，仅仅调用openCameraForUid方法，最终主要调用openCameraDeviceUserAsync方法。 */
/* CameraManager.java */
public void openCameraForUid(@NonNull String cameraId,
        @NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler,
        int clientUid)
        throws CameraAccessException {
   

    if (handler == null) {
   
         /* Looper:消息的遍历者，从MessageQueue中循环取出Message进行处理，一个线程最多只有一个。Looper作为Handler消息机制的“动力引擎”，不断从MessageQueue中获取消息，然后交给Handler去处理。Looper的使用前需要先初始化当前线程的Looper对象，再调用loop方法来启动它。同时Handler也是实现切换的核心，因为不同的Looper运行在不同的线程，他所调用的dispatchMessage方法则运行在不同的线程，所以Message的处理就被切换到Looper所在的线程了。当looper不再使用时，可调用不同的退出方法来退出他，注意Looper一旦退出，线程则会直接结束。*/
        if (Looper.myLooper() != null) {
   
            handler = new Handler();
        } else {
   
            throw new IllegalArgumentException(
                    "Handler argument is null, but no looper exists in the calling thread");
        }
    }
    openCameraDeviceUserAsync(cameraId, callback, handler, clientUid);
}

/* CameraManager.java */
private CameraDevice openCameraDeviceUserAsync(String cameraId,
        CameraDevice.StateCallback callback, Handler handler, final int uid)
        throws CameraAccessException {
   
    /* 获得 camera 的信息，这个函数会使用 CameraService binder 服务来得到信息 */
    CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);
    CameraDevice device = null;

    synchronized (mLock) {
   

        ICameraDeviceUser cameraUser = null;
        /* 创建 CameraDeviceImpl 对象，它继承自 CameraDevice */
        android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =
                new android.hardware.camera2.impl.CameraDeviceImpl(
                    cameraId,
                    callback,
                    handler,
                    characteristics,
                    mContext.getApplicationInfo().targetSdkVersion);
        /*
         * 获得回调， 这个回调很重要
         * 处理好的图像帧会通过这个回调传回上层，这是提供给远端连接到 CameraDeviceImpl 的接口。
         */
        ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();

        try {
   
			/*HAL3 中走的是这一部分逻辑，主要是从 CameraManagerGlobal 中获取 CameraService 的本地接口，通过它远端调用 connectDevice 方法连接到相机设备。注意返回的 cameraUser 实际上指向的是远端 CameraDeviceClient 的本地接口。*/
			ICameraService cameraService = CameraManagerGlobal.get().getCameraService();
            if (cameraService == null) {
   
                throw new ServiceSpecificException(
                    ICameraService.ERROR_DISCONNECTED,
                    "Camera service is currently unavailable");
            }
            cameraUser = cameraService.connectDevice(callbacks, cameraId,
                mContext.getOpPackageName(),  mContext.getAttributionTag(), uid,
                oomScoreOffset, mContext.getApplicationInfo().targetSdkVersion);
        } catch (ServiceSpecificException e) {
   
            ......
        } catch (RemoteException e) {
   
            ......
        }

        /* 将 CameraDeviceClient 设置到 CameraDeviceImpl 中进行管理。*/
        deviceImpl.setRemoteDevice(cameraUser);
        device = deviceImpl;
    }

    return device;
}

/* CameraDeviceImpl.java */
/*
	CameraDevice具体实现。使用 CameraManager#open 实例化。
	1. 获取 TAG
	2. 获取 partialCount
*/
public class CameraDeviceImpl extends CameraDevice
        implements IBinder.DeathRecipient {
   
	...
    public CameraDeviceImpl(String cameraId, StateCallback callback, Executor executor,
                        CameraCharacteristics characteristics, int appTargetSdkVersion) {
   
        if (cameraId == null || callback == null || executor == null || characteristics == null) {
   
            throw new IllegalArgumentException("Null argument given");
        }
        mCameraId = cameraId;
        mDeviceCallback = callback;
        mDeviceExecutor = executor;
        mCharacteristics = characteristics;
        mAppTargetSdkVersion = appTargetSdkVersion;

        final int MAX_TAG_LEN = 23;
        String tag = String.format("CameraDevice-JV-%s", mCameraId);
        if (tag.length() > MAX_TAG_LEN) {
   
            tag = tag.substring(0, MAX_TAG_LEN);
        }
        TAG = tag;

        Integer partialCount = mCharacteristics.get(CameraCharacteristics.REQUEST_PARTIAL_RESULT_COUNT);
        /* REQUEST_PARTIAL_RESULT_COUNT 定义结果将由多少个子组件组成。为了消除流水线延迟，可以在部分结果可用时立即将其从相机设备传递到应用程序层。*/
        if (partialCount