【Camera专题】HAL层-深入浅出startPreview

说在前面的话

现在阅读的是HAL1的源码，因为项目目前还是Android 7.1，用的是HAL 1，而HAL 3有很大的改动！！！
有点不知道怎么说才好。
不论如何，把一个搞懂了，另一个理解起来也会容易一些吧！

不去抱怨，就努力去做吧！！！

一.知识点

1. C++多线程知识

2. startPreview的流程和深度解析

读完本文，未来在面试的时候，如果面试官问到这一块，希望你得心应手！

二.C++的多线程知识

这是看本文必备的C++基础知识，如果你对多线程不了解，可以阅读以下文章：
1. 菜鸟教程-C++多线程基础
2. pthread_mutex_t 和 pthread_cond_t 配合使用的简要分析
3. 多线程之pthread_create（）函数
4. 条件变量、pthread_cond_init
5. linux线程互斥量pthread_mutex_t使用简介

三.startPreview的流程和深度解析

3.1 startPreview的流程图

3.2 从log中看startPreview

QCamera2Factory::cameraDeviceOpen(int, hw_device_t**) :zcf E
QCameraStateMachine(qcamera::QCamera2HardwareInterface*):zcf X
QCameraStateMachine(qcamera::QCamera2HardwareInterface*):zcf thread id=-1401407200
QCameraStateMachine(qcamera::QCamera2HardwareInterface*):zcf E
QCamera2Factory::cameraDeviceOpen(int, hw_device_t**):zcf X

Camera-JNI: zcf startPreview
Camera NA: zcf startPreview
CameraClient: zcf startPreview (pid 3857)
CameraClient: zcf startCameraMode(0)
CameraClient: zcf startPreviewMode
CameraFlashlight: [zcf] startPreview  (0)
QCamera2HardwareInterface::start_preview(camera_device*): zcf E

qcamera::QCameraStateMachine::procEvtPreviewStoppedState(···):
zcf mPreviewWindow != NULL,call preparePreview

QCamera2HWI: int32_t qcamera::QCamera2HardwareInterface::preparePreview(): zcf E
QCamera2HWI: int32_t qcamera::QCamera2HardwareInterface::preparePreview(): zcf X
QCameraStateMachine::procEvtPreviewStoppedState(···):
zcf call startPreview

QCamera2HWI: int qcamera::QCamera2HardwareInterface::startPreview(): zcf  E
QCamera2HWI: int qcamera::QCamera2HardwareInterface::startPreview(): zcf X
QCameraStateMachine::procEvtPreviewStoppedState(···):
zcf start preview success, move to previewing state

QCamera2HardwareInterface::start_preview(camera_device*): zcf X

从log中，可以很清晰的看到方法的调用流程，
有时候，看源码不知道是调用的哪里，自己添加一些log，打印出来，就很清晰了！
log截图

3.3 深度解析

---

3.3.1 open简析
首先startPreview之前，肯定是先open Camera的流程，但这不是本文的重点，因此简要分析吧！

a) qcamera::QCamera2Factory::cameraDeviceOpen

int QCamera2Factory::cameraDeviceOpen(int camera_id,
                    struct hw_device_t **hw_device)
{
    int rc = NO_ERROR;
    ALOGE("%s zcf E",__func__);
    if (camera_id < 0 || camera_id >= mNumOfCameras)
        return BAD_VALUE;
//这里new了一个QCamera2HardwareInterface 实例(对象)
    QCamera2HardwareInterface *hw = new QCamera2HardwareInterface((uint32_t)camera_id);
    if (!hw) {
        ALOGE("Allocation of hardware interface failed");
        return NO_MEMORY;
    }
//调用QCamera2HardwareInterface 里的openCamera()方法
    rc = hw->openCamera(hw_device);
    if (rc != NO_ERROR) {
        delete hw;
    }
    ALOGE("%s zcf X",__func__);
    return rc;
}

• 1. new QCamera2HardwareInterface((uint32_t)camera_id)的实例

当系统new这个QCamera2HardwareInterface对象时，首先会调用QCameraStateMachine的构造方法，
然后在调用QCamera2HardwareInterface的构造方法。
因为QCameraStateMachine 是QCamera2HardwareInterface的一个成员变量！
其定义如下：

class QCamera2HardwareInterface : public QCameraAllocator,
                                public QCameraThermalCallback,
                                  public QCameraAdjustFPS,
                              public QCameraTorchInterface
{
···
pubulic:
friend class QCameraStateMachine;
···
private:
QCameraStateMachine m_stateMachine;   // state machine
···
}

• 2. 调用hw->openCamera(hw_device);
     QCamera2HardwareInterface 对象有了之后，就去调用openCamera方法，
     后续的openCamera就不再分析。

b) QCameraStateMachine::QCameraStateMachine构造方法

QCameraStateMachine::QCameraStateMachine(QCamera2HardwareInterface *ctrl) :
    api_queue(),
    evt_queue()
{
    CDBG_HIGH("%s:zcf X", __func__);
    m_parent = ctrl;//注意 m_parent 就是 QCamera2HardwareInterface 实例对象
    m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
    cmd_pid = 0; 
    cam_sem_init(&cmd_sem, 0);//初始化信号量
    //创建线程
    pthread_create(&cmd_pid,
                   NULL,
                   smEvtProcRoutine,
                   this);
    CDBG_HIGH("%s:zcf thread id=%d", __func__,cmd_pid);
    pthread_setname_np(cmd_pid, "CAM_stMachine");
    CDBG_HIGH("%s:zcf E", __func__);
}

QCameraStateMachine这个类是用来管理Camera的运行状态的，
比如：处于预览、拍照或者录屏状态。

• 1首先初始化了2个队列：
  api_queue()：处理来自framework的API请求
  evt_queue()：处理来自framework的event请求

• 2. m_parent = ctrl; m_parent 就是 QCamera2HardwareInterface 实例对象
• 3.设置初始状态： m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
• 4.cam_sem_init(&cmd_sem, 0)初始化信号量
• 5.pthread_create创建线程，名称为：CAM_stMachine，线程函数smEvtProcRoutine。
  这里就用到C++多线程知识了，这个线程，下文分析会用到的！

PS：下面的分析会用到这里的知识，请留意！！！

---

3.3.2 startPreview 分析

a) JNI 层

调用流程：APP->Framework层->JNI->Native->HAL层->Kernel层。
frameworks/base/core/java/android/hardware/Camera.java
framework层中定义native方法：

    /**  
     * Starts capturing and drawing preview frames to the screen.
     * Preview will not actually start until a surface is supplied
     * with {@link #setPreviewDisplay(SurfaceHolder)} or
     * {@link #setPreviewTexture(SurfaceTexture)}.
     *
     * 
If {@link #setPreviewCallback(Camera.PreviewCallback)},
     * {@link #setOneShotPreviewCallback(Camera.PreviewCallback)}, or
     * {@link #setPreviewCallbackWithBuffer(Camera.PreviewCallback)} were
     * called, {@link Camera.PreviewCallback#onPreviewFrame(byte[], Camera)}
     * will be called when preview data becomes available.
     */
    public native final void startPreview();

进入JNI层调用相关方法：

static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
{
    ALOGD("zcf startPreview");
    sp camera = get_native_camera(env, thiz, NULL);
    if (camera == 0) return;

    if (camera->startPreview() != NO_ERROR) {
        jniThrowRuntimeException(env, "startPreview failed");
        return;
    }    
}

b) Native层

frameworks/av/camera/Camera.cpp

// start preview mode
status_t Camera::startPreview()
{
    ALOGE("zcf startPreview");
    sp <::android::hardware::ICamera> c = mCamera;
    if (c == 0) return NO_INIT;
    return c->startPreview();
}

这里的ICamera类型实际上是CameraClient，因此会调用到CameraClient::startPreview。

另外你也可以从log中看到调用流程：
Camera-JNI: zcf startPreview
Camera NA: zcf startPreview
CameraClient: zcf startPreview (pid 3857)
CameraClient: zcf startPreviewMode

frameworks/av/services/camera/libcameraservice/api1/CameraClient.cpp

// start preview mode
status_t CameraClient::startPreview() {
    LOG1("zcf startPreview (pid %d)", getCallingPid());
    return startCameraMode(CAMERA_PREVIEW_MODE);
}

这里传入的类型是CAMERA_PREVIEW_MODE

// start preview or recording
status_t CameraClient::startCameraMode(camera_mode mode) {
    LOG1("zcf startCameraMode(%d)", mode);
    Mutex::Autolock lock(mLock);
    status_t result = checkPidAndHardware();
    if (result != NO_ERROR) return result;

    switch(mode) {
        //照相模式下的预览
        case CAMERA_PREVIEW_MODE:
            if (mSurface == 0 && mPreviewWindow == 0) {
                LOG1("mSurface is not set yet.");
                // still able to start preview in this case.
            }
            return startPreviewMode();
        //录像模式下的预览
        case CAMERA_RECORDING_MODE:
            if (mSurface == 0 && mPreviewWindow == 0) {
                ALOGE("mSurface or mPreviewWindow must be set before startRecordingMode.");
                return INVALID_OPERATION;
            }
            return startRecordingMode();
        default:
            return UNKNOWN_ERROR;
    }
}

在照相预览模式中，调用startPreviewMode方法：

status_t CameraClient::startPreviewMode() {
    LOG1("zcf startPreviewMode");
    status_t result = NO_ERROR;

    // if preview has been enabled, nothing needs to be done
    //如果当前已经处于预览模式，则直接返回
    if (mHardware->previewEnabled()) {
        return NO_ERROR;
    }    
     
    if (mPreviewWindow != 0) { 
        //设置窗口的缩放比例
        mHardware->setPreviewScalingMode(
            NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
        //设置预览数据的方向：水平，垂直，或者2者结合
        mHardware->setPreviewTransform(mOrientation);
    }    
    //设置当前显示窗口
    mHardware->setPreviewWindow(mPreviewWindow);
   //调用HAL层的startPreview方法
    result = mHardware->startPreview();
    //接收返回值
    if (result == NO_ERROR) {
        //若HAL层返回成功，
        //通过代理通知CameraService当前的camera状态：CAMERA_STATE_ACTIVE
        mCameraService->updateProxyDeviceState(
            ICameraServiceProxy::CAMERA_STATE_ACTIVE,
            String8::format("%d", mCameraId));
    }    
    return result;
}

应用启动时，会设置预览窗口，对应的就是这里的mPreviewWindow。
后续调用HAL的startPreview方法！
这里的mHardware = new CameraHardwareInterface(camera_device_name);

c) HAL层
frameworks/av/services/camera/libcameraservice/device1/CameraHardwareInterface.h
先看一下log打印：
CameraFlashlight: [zcf] startPreview (0)
一开始我还以为调用到CameraFlashlight类的startPreview 呢，
这是我添加的log：
ALOGE("[zcf] %s (%s)", FUNCTION, mName.string());
实际上是这个ALOGE定义的问题，它打印的TAG是CameraFlashlight。

总之是调用到CameraHardwareInterface的startPreview

/** 
 * Start preview mode.
 */
status_t startPreview()
{   
    ALOGE("[zcf] %s (%s)", __FUNCTION__, mName.string());
    if (mDevice->ops->start_preview)
        return mDevice->ops->start_preview(mDevice);
    return INVALID_OPERATION;
} 

其中：mDevice->ops会在Camera初始化的时候【其实就是调用QCamera2HardwareInterface构造方法的时候】，
绑定所有跟camera相关的操作方法。

QCamera2HardwareInterface::QCamera2HardwareInterface(uint32_t cameraId)
{
···
    mCameraDevice.ops = &mCameraOps;
···
}

接下来调用的是：mDevice->ops->start_preview(mDevice)
这是log：
QCamera2HWI: static int qcamera::QCamera2HardwareInterface::start_preview(camera_device*): zcf E

hardware/qcom/camera/QCamera2/HAL/QCamera2HWI.cpp

int QCamera2HardwareInterface::start_preview(struct camera_device *device)
{
    CDBG_HIGH("%s: zcf E", __func__);
    ATRACE_CALL();
    int ret = NO_ERROR;
    //这里的device指针强转成QCamera2HardwareInterface 类型
    QCamera2HardwareInterface *hw =
        reinterpret_cast(device->priv);
    if (!hw) {
        ALOGE("NULL camera device");
        return BAD_VALUE;
    }    
    CDBG_HIGH("[KPI Perf] %s: E PROFILE_START_PREVIEW", __func__);
    //线程锁
    hw->lockAPI();
    qcamera_api_result_t apiResult;
    //事件类型 QCAMERA_SM_EVT_START_PREVIEW
    qcamera_sm_evt_enum_t evt = QCAMERA_SM_EVT_START_PREVIEW;
    if (hw->isNoDisplayMode()) {
        CDBG_HIGH("%s: zcf isNoDisplayMode ", __func__);
        evt = QCAMERA_SM_EVT_START_NODISPLAY_PREVIEW;
    }    
    //发送事件
    ret = hw->processAPI(evt, NULL);
    if (ret == NO_ERROR) {
        //解锁并且等待线程唤醒
        hw->waitAPIResult(evt, &apiResult);
        ret = apiResult.status;
    }    
    //解锁
    hw->unlockAPI();
    hw->m_bPreviewStarted = true;
    CDBG_HIGH("[KPI Perf] %s: X", __func__);
    CDBG_HIGH("%s: zcf X", __func__);
    return ret; 
}

分析到这里，就要用到我们C++的线程知识了

• 1.首先设置evt = QCAMERA_SM_EVT_START_PREVIEW，通过hw->processAPI(evt, NULL)发送事件。

int QCamera2HardwareInterface::processAPI(qcamera_sm_evt_enum_t api, void *api_payload)
{
    int ret = DEAD_OBJECT;

    if (m_smThreadActive) {
        ret = m_stateMachine.procAPI(api, api_payload);
    }

    return ret;
}

其中m_stateMachine类型：QCameraStateMachine m_stateMachine;
调用procAPI，该函数作用：处理来自framew层的传入API请求。

hardware/qcom/camera/QCamera2/HAL/QCameraStateMachine.cpp

int32_t QCameraStateMachine::procAPI(qcamera_sm_evt_enum_t evt, 
                                     void *api_payload)
{
    //申请内存
    qcamera_sm_cmd_t *node =
        (qcamera_sm_cmd_t *)malloc(sizeof(qcamera_sm_cmd_t));
    if (NULL == node) {
        ALOGE("%s: No memory for qcamera_sm_cmd_t", __func__);
        return NO_MEMORY;
    }    

    memset(node, 0, sizeof(qcamera_sm_cmd_t));
    //设置CMD类型为：QCAMERA_SM_CMD_TYPE_API
    node->cmd = QCAMERA_SM_CMD_TYPE_API;
    node->evt = evt; 
    node->evt_payload = api_payload;
    //node进入事件队列
    if (api_queue.enqueue((void *)node)) {
        //内核锁
        cam_sem_post(&cmd_sem);
        return NO_ERROR;
    } else {
        free(node);
        return UNKNOWN_ERROR;
    }    
}

这里
node->cmd = QCAMERA_SM_CMD_TYPE_API;
node->evt = evt;
node->evt_payload = api_payload;
然后入队！
api_queue.enqueue((void *)node）

这里的线程就是CAM_stMachine，处理了入队，也会处理出队。
还记得我们3.3.1节中分析的
pthread_create创建线程，名称为：CAM_stMachine，线程函数smEvtProcRoutine。
我们来看这个线程函数：

void *QCameraStateMachine::smEvtProcRoutine(void *data)
{
    int running = 1, ret;
    QCameraStateMachine *pme = (QCameraStateMachine *)data;

    CDBG_HIGH("%s: E", __func__);
    do {//死循环
        do {
            //这里线程先条件等待：ret != 0
            ret = cam_sem_wait(&pme->cmd_sem);
            if (ret != 0 && errno != EINVAL) {
                ALOGE("%s: cam_sem_wait error (%s)",
                           __func__, strerror(errno));
                return NULL;
            }
        } while (ret != 0);

        // we got notified about new cmd avail in cmd queue
        // first check API cmd queue：先检查API命令队列
        //前面入队，这里就出队列了，看到了吗
        qcamera_sm_cmd_t *node = (qcamera_sm_cmd_t *)pme->api_queue.dequeue();
        if (node == NULL) {
            // no API cmd, then check evt cmd queue
           //如果没有API命令，在检查evnet命令，这里出队
            node = (qcamera_sm_cmd_t *)pme->evt_queue.dequeue();
        }
        if (node != NULL) {
            switch (node->cmd) {
            //我们对应的是这个API事件
            case QCAMERA_SM_CMD_TYPE_API:
                pme->stateMachine(node->evt, node->evt_payload);
                // API is in a way sync call, so evt_payload is managed by HWI
                // no need to free payload for API
                break;
            case QCAMERA_SM_CMD_TYPE_EVT:
                pme->stateMachine(node->evt, node->evt_payload);

                // EVT is async call, so payload need to be free after use
                free(node->evt_payload);
                node->evt_payload = NULL;
                break;
            case QCAMERA_SM_CMD_TYPE_EXIT:
                running = 0;
                break;
            default:
                break;
            }
            free(node);
            node = NULL;
        }
    } while (running);
    CDBG_HIGH("%s: X", __func__);
    return NULL;
}

3.3.1节就分析过，事件分2种：1.API事件，2.evt事件，优先处理API事件！
这里的TYPE为：QCAMERA_SM_CMD_TYPE_API
因此继续调用：
pme->stateMachine(node->evt, node->evt_payload);

int32_t QCameraStateMachine::stateMachine(qcamera_sm_evt_enum_t evt, void *payload)
{
    int32_t rc = NO_ERROR;
    switch (m_state) {
    case QCAMERA_SM_STATE_PREVIEW_STOPPED:
        rc = procEvtPreviewStoppedState(evt, payload);
        break;
    case QCAMERA_SM_STATE_PREVIEW_READY:
        rc = procEvtPreviewReadyState(evt, payload);
        break;
    case QCAMERA_SM_STATE_PREVIEWING:
        rc = procEvtPreviewingState(evt, payload);
        break;
    case QCAMERA_SM_STATE_PREPARE_SNAPSHOT:
        rc = procEvtPrepareSnapshotState(evt, payload);
        break;
···省略
    }

这里根据m_sate来调用不同的函数，还记得吗，3.3.1节中分析的：
初始状态： m_state = QCAMERA_SM_STATE_PREVIEW_STOPPED;
因此会继续调用procEvtPreviewStoppedState(evt, payload);

int32_t QCameraStateMachine::procEvtPreviewStoppedState(qcamera_sm_evt_enum_t evt,
                                                        void *payload)
{
    int32_t rc = NO_ERROR;
    qcamera_api_result_t result;
    memset(&result, 0, sizeof(qcamera_api_result_t));

    switch (evt) {
    case QCAMERA_SM_EVT_SET_PREVIEW_WINDOW:
    ···
         break;
    case QCAMERA_SM_EVT_SET_CALLBACKS:
    ···
        break;
···省略多个case
    case QCAMERA_SM_EVT_START_PREVIEW:
        {
            if (m_parent->mPreviewWindow == NULL) {
                    ALOGE("%s: zcf mPreviewWindow == NULL,call preparePreview",__func__);
                rc = m_parent->preparePreview();//preview的准备工作
                if(rc == NO_ERROR) {//设置状态为QCAMERA_SM_STATE_PREVIEW_READY
                    ALOGE("%s: zcf preview window is not set yet, move to previewReady state",__func__);
                    // preview window is not set yet, move to previewReady state
                    m_state = QCAMERA_SM_STATE_PREVIEW_READY;
                } else {
                    ALOGE("%s: preparePreview failed",__func__);
                }
            } else {//我们基本走的是这个分支
                    ALOGE("%s: zcf mPreviewWindow != NULL,call preparePreview",__func__);
                rc = m_parent->preparePreview();//preparePreview准备工作
                if (rc == NO_ERROR) {
                    ALOGE("%s: zcf call startPreview",__func__);
                    rc = m_parent->startPreview();//调用startPreview
                    if (rc != NO_ERROR) {
                        m_parent->unpreparePreview();
                    } else {
                        // start preview success, move to previewing state
                        ALOGE("%s: zcf start preview success, move to previewing state",__func__);
                        m_state = QCAMERA_SM_STATE_PREVIEWING;
                    }
                }
            }
            result.status = rc;//返回结果
            result.request_api = evt;//
            result.result_type = QCAMERA_API_RESULT_TYPE_DEF;
            m_parent->signalAPIResult(&result);//这里去唤醒等待线程
        }
        break;
···
}

这里的 m_parent 就是 QCamera2HardwareInterface 实例对象(3.3.1节分析过)。
因而分别调用的是
QCamera2HardwareInterface::preparePreview()
QCamera2HardwareInterface::startPreview()
我们顺便看一下之前的log流程：

procEvtPreviewStoppedState(···): zcf mPreviewWindow != NULL,call preparePreview
QCamera2HardwareInterface::preparePreview(): zcf E
QCamera2HardwareInterface::preparePreview(): zcf X
procEvtPreviewStoppedState(···): zcf call startPreview

preparePreview简析

int32_t QCamera2HardwareInterface::preparePreview()
{
    ATRACE_CALL();
    int32_t rc = NO_ERROR;

        CDBG_HIGH("%s: zcf E", __func__);
    //如果开启ZSL模式，且不是录像模式
    if (mParameters.isZSLMode() && mParameters.getRecordingHintValue() !=true) {
        rc = addChannel(QCAMERA_CH_TYPE_ZSL);//添加ZSL通道
        if (rc != NO_ERROR) {
            return rc;
        }
    } else {
        bool recordingHint = mParameters.getRecordingHintValue();
        if(recordingHint) {
            //stop face detection,longshot,etc if turned ON in Camera mode
            int32_t arg; //dummy arg
#ifndef VANILLA_HAL
            if (isLongshotEnabled()) {
                sendCommand(CAMERA_CMD_LONGSHOT_OFF, arg, arg);
            }
#endif
            if (mParameters.isFaceDetectionEnabled()) {
                sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, arg, arg);
            }
#ifndef VANILLA_HAL
            if (mParameters.isHistogramEnabled()) {
                sendCommand(CAMERA_CMD_HISTOGRAM_OFF, arg, arg);
            }
#endif

            cam_dimension_t videoSize;
            mParameters.getVideoSize(&videoSize.width, &videoSize.height);
            if (!is4k2kResolution(&videoSize) && !mParameters.isLowPowerEnabled()) {
               rc = addChannel(QCAMERA_CH_TYPE_SNAPSHOT);
               if (rc != NO_ERROR) {
                   return rc;
               }
            }
            rc = addChannel(QCAMERA_CH_TYPE_VIDEO);
            if (rc != NO_ERROR) {
                delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
                return rc;
            }
        }
        //添加preview通道
        rc = addChannel(QCAMERA_CH_TYPE_PREVIEW);
        if (rc != NO_ERROR) {
            if (recordingHint) {
                delChannel(QCAMERA_CH_TYPE_SNAPSHOT);
                delChannel(QCAMERA_CH_TYPE_VIDEO);
            }
            return rc;
        }

        if (!recordingHint) {
            waitDefferedWork(mMetadataJob);
        }
    }

    CDBG_HIGH("%s: zcf X", __func__);
    return rc;
}

最主要的是 rc = addChannel(QCAMERA_CH_TYPE_PREVIEW);添加Preview通道！
后续addChannel涉及到数据流的东西，暂时先不分析了，另起一篇文章分析！
接下来调用QCamera2HardwareInterface::startPreview()

QCamera2HardwareInterface::startPreview()分析

hardware/qcom/camera/QCamera2/HAL/QCamera2HWI.cpp

int QCamera2HardwareInterface::startPreview()
{
    ATRACE_CALL();
    int32_t rc = NO_ERROR;
    CDBG_HIGH("%s: zcf  E", __func__);
    updateThermalLevel(mThermalLevel);
    // start preview stream 开启数据流
    if (mParameters.isZSLMode() && mParameters.getRecordingHintValue() !=true) {
        //ZSL模式，添加ZSL数据流
        rc = startChannel(QCAMERA_CH_TYPE_ZSL);
    } else {
        //非ZSL模式，普通Preview数据流
        rc = startChannel(QCAMERA_CH_TYPE_PREVIEW);
        /*
          CAF needs cancel auto focus to resume after snapshot.
          Focus should be locked till take picture is done.
          In Non-zsl case if focus mode is CAF then calling cancel auto focus
          to resume CAF.
        */
        cam_focus_mode_type focusMode = mParameters.getFocusMode();
        if (focusMode == CAM_FOCUS_MODE_CONTINOUS_PICTURE)
            mCameraHandle->ops->cancel_auto_focus(mCameraHandle->camera_handle);
    }
#ifdef TARGET_TS_MAKEUP
    if (mMakeUpBuf == NULL) {
        int pre_width, pre_height;
        mParameters.getPreviewSize(&pre_width, &pre_height);
        mMakeUpBuf = new unsigned char[pre_width*pre_height*3/2];
        CDBG_HIGH("prewidht=%d,preheight=%d",pre_width, pre_height);
    }
#endif
    CDBG_HIGH("%s: zcf X", __func__);
    return rc;
}

兜兜转转，最后调用到
rc = startChannel(QCAMERA_CH_TYPE_PREVIEW);
通过该函数preview数据流，至于startChannel做了什么，就涉及到数据流的东西了，
另起一篇文章分析！
再看看log

QCamera2HWI: int qcamera::QCamera2HardwareInterface::startPreview(): zcf  E
QCamera2HWI: int qcamera::QCamera2HardwareInterface::startPreview(): zcf X
QCameraStateMachine: int32_t qcamera::QCameraStateMachine::procEvtPreviewStoppedState(···): 
zcf start preview success, move to previewing state
QCamera2HWI: static int qcamera::QCamera2HardwareInterface::start_preview(camera_device*): zcf X

执行完QCamera2HardwareInterface::startPreview之后，
最终设置Camera状态：QCAMERA_SM_STATE_PREVIEWING

贴一份log截图：startPreview没有冷启动热启动这样的说法

Stay Hungry！Stay Foolish！