1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# frameworks/ex/camera2/portability/src/com/android/ex/camera2/portability/CameraAgentFactory.java
/*
*  CameraAgentFactory使用了简单工厂模式，通过传参选择类型
*/ 
public static synchronized CameraAgent getAndroidCameraAgent(Context context, CameraApi api) {
    api = validateApiChoice(api);

    if (api == CameraApi.API_1) {
        if (sAndroidCameraAgent == null) {
            sAndroidCameraAgent = new AndroidCameraAgentImpl();
            sAndroidCameraAgentClientCount = 1;
        } else {
            ++sAndroidCameraAgentClientCount;
        }
        return sAndroidCameraAgent;
    } else { // API_2
        if (highestSupportedApi() == CameraApi.API_1) {
            throw new UnsupportedOperationException("Camera API_2 unavailable on this device");
        }

        if (sAndroidCamera2Agent == null) {
            sAndroidCamera2Agent = new AndroidCamera2AgentImpl(context);
            sAndroidCamera2AgentClientCount = 1;
        } else {
            ++sAndroidCamera2AgentClientCount;
        }
        return sAndroidCamera2Agent;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
# frameworks/ex/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java
/*
* CameraAgent
*/
public void openCamera(final Handler handler, final int cameraId,
                           final CameraOpenCallback callback) {
        try {
            getDispatchThread().runJob(new Runnable() {
                @Override
                public void run() {
                    //发送类型为OPEN_CAMERA的消息
                    getCameraHandler().obtainMessage(CameraActions.OPEN_CAMERA, cameraId, 0,
                            CameraOpenCallbackForward.getNewInstance(handler, callback)).sendToTarget();
                }
            });
        } catch (final RuntimeException ex) {
            getCameraExceptionHandler().onDispatchThreadException(ex);
        }
    }
    
# frameworks/ex/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java

@Override
public void handleMessage(final Message msg) {
    super.handleMessage(msg);
    ....
    int cameraAction = msg.what;
    try {
        switch (cameraAction) {
            case CameraActions.OPEN_CAMERA: {
                final CameraOpenCallback openCallback = (CameraOpenCallback) msg.obj;
                final int cameraId = msg.arg1;
                if (mCameraState.getState() != AndroidCameraStateHolder.CAMERA_UNOPENED) {
                    openCallback.onDeviceOpenedAlready(cameraId, generateHistoryString(cameraId));
                    break;
                }

                Log.i(TAG, "Opening camera " + cameraId + " with camera1 API");
                //使用Camera API1的方式打开camera
                mCamera = android.hardware.Camera.open(cameraId);
                if (mCamera != null) {
                    mCameraId = cameraId;
                    mParameterCache = new ParametersCache(mCamera);

                    mCharacteristics = AndroidCameraDeviceInfo.create().getCharacteristics(cameraId);
                    mCapabilities = new AndroidCameraCapabilities(
                            mParameterCache.getBlocking());

                    mCamera.setErrorCallback(this);
                    mCameraState.setState(AndroidCameraStateHolder.CAMERA_IDLE);
                    if (openCallback != null) {
                        CameraProxy cameraProxy = new AndroidCameraProxyImpl(
                                mAgent, cameraId, mCamera, mCharacteristics, mCapabilities);
                        openCallback.onCameraOpened(cameraProxy);
                    }
                } else {
                    if (openCallback != null) {
                        openCallback.onDeviceOpenFailure(cameraId, generateHistoryString(cameraId));
                    }
                }
                break;
            }
        ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
Status CameraService::makeClient(const sp<CameraService>& cameraService,
        const sp<IInterface>& cameraCb, const String16& packageName,
        const std::optional<String16>& featureId, const String8& cameraId, int api1CameraId,
        int facing, int clientPid, uid_t clientUid, int servicePid, int halVersion,
        int deviceVersion, apiLevel effectiveApiLevel,
        /*out*/sp<BasicClient>* client) {
    //初始化halVersion小于0
    if (halVersion < 0 || halVersion == deviceVersion) {
        /*
        * 此处通过deviceVersion类型创建client。
        * HAL1: CameraClient
        * HAL3: Camera2Client
        */
        switch(deviceVersion) {
          case CAMERA_DEVICE_API_VERSION_1_0:
            if (effectiveApiLevel == API_1) {  // Camera1 API route
                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
                *client = new CameraClient(cameraService, tmp, packageName, featureId,
                        api1CameraId, facing, clientPid, clientUid,
                        getpid());
            } else { // Camera2 API route
                ALOGW("Camera using old HAL version: %d", deviceVersion);
                return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
                        "Camera device \"%s\" HAL version %d does not support camera2 API",
                        cameraId.string(), deviceVersion);
            }
            break;
          case CAMERA_DEVICE_API_VERSION_3_0:
          case CAMERA_DEVICE_API_VERSION_3_1:
          case CAMERA_DEVICE_API_VERSION_3_2:
          case CAMERA_DEVICE_API_VERSION_3_3:
          case CAMERA_DEVICE_API_VERSION_3_4:
          case CAMERA_DEVICE_API_VERSION_3_5:
          case CAMERA_DEVICE_API_VERSION_3_6:
            if (effectiveApiLevel == API_1) { // Camera1 API route
                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
                *client = new Camera2Client(cameraService, tmp, packageName, featureId,
                        cameraId, api1CameraId,
                        facing, clientPid, clientUid,
                        servicePid);
            } else { // Camera2 API route
                sp<hardware::camera2::ICameraDeviceCallbacks> tmp =
                        static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
                *client = new CameraDeviceClient(cameraService, tmp, packageName, featureId,
                        cameraId, facing, clientPid, clientUid, servicePid);
            }
            break;
          default:
            // Should not be reachable
            ALOGE("Unknown camera device HAL version: %d", deviceVersion);
            return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
                    "Camera device \"%s\" has unknown HAL version %d",
                    cameraId.string(), deviceVersion);
        }
    } else {
        // A particular HAL version is requested by caller. Create CameraClient
        // based on the requested HAL version.
        if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
            halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
            // Only support higher HAL version device opened as HAL1.0 device.
            sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
            *client = new CameraClient(cameraService, tmp, packageName, featureId,
                    api1CameraId, facing, clientPid, clientUid,
                    servicePid);
        } else {
            // Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
            ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
                    " opened as HAL %x device", halVersion, deviceVersion,
                    CAMERA_DEVICE_API_VERSION_1_0);
            return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
                    "Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
                    cameraId.string(), deviceVersion, halVersion);
        }
    }
    return Status::ok();
}