本文章转载自sheldon_blogs的博客，具体网址如下：https://www.cnblogs.com/blogs-of-lxl/p/5152578.html
本文章仅供学习研究使用，如须转载请附上原作者名称及网址

/*** 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)}.** <p>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();  //给上层 application 提供一个接口， 进入 Runtime 层。

static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
{ALOGV("startPreview");sp<Camera> camera = get_native_camera(env, thiz, NULL); //调用 get_native_camera() 函数获取一个 Camera 实例。if (camera == 0) return;
​if (camera->startPreview() != NO_ERROR) {jniThrowRuntimeException(env, "startPreview failed");return;}
}sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, JNICameraContext** pContext)
{sp<Camera> camera;Mutex::Autolock _l(sLock);JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); //从 DVM 中获取关于 Camera 的上下文。if (context != NULL) {camera = context->getCamera(); //从上下文信息中获取 Camera 实例。}ALOGV("get_native_camera: context=%p, camera=%p", context, camera.get());if (camera == 0) {jniThrowRuntimeException(env,"Camera is being used after Camera.release() was called");}
​if (pContext != NULL) *pContext = context;return camera;
}

// start preview mode
status_t Camera::startPreview()
{ALOGV("startPreview");sp <::android::hardware::ICamera> c = mCamera; //mCamera 即是在 connect 过程中返回的 CameraClient，它具体实现了 startPreview() 接口。if (c == 0) return NO_INIT;return c->startPreview();
}

// start preview mode
status_t CameraClient::startPreview() {LOG1("startPreview (pid %d)", getCallingPid());return startCameraMode(CAMERA_PREVIEW_MODE); //通过 startCameraMode 函数进入具体的实现逻辑。
}

// start preview or recording
status_t CameraClient::startCameraMode(camera_mode mode) { //根据传入的参数 CAMERA_PREVIEW_MODE 确定进入的分支。LOG1("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();//调用 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;}
}

status_t CameraClient::startPreviewMode() {LOG1("startPreviewMode");status_t result = NO_ERROR;
​// if preview has been enabled, nothing needs to be doneif (mHardware->previewEnabled()) { return NO_ERROR; //如果预览已经存在，则直接返回成功信息。}
​if (mPreviewWindow != 0) {mHardware->setPreviewScalingMode( //mHardware 是 CameraHardwareInterface 的实例，在 connect 过程的最后被初始化。NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);mHardware->setPreviewTransform(mOrientation);}mHardware->setPreviewWindow(mPreviewWindow); //通过 mHardware 调用 setPreviewWindow() 和 startPreview() 接口。result = mHardware->startPreview();if (result == NO_ERROR) {mCameraService->updateProxyDeviceState( //进入 HAL 层。ICameraServiceProxy::CAMERA_STATE_ACTIVE,String8::format("%d", mCameraId));}return result;
}

/*** Returns true if preview is enabled.*/int previewEnabled(){ALOGV("%s(%s)", __FUNCTION__, mName.string());if (mDevice->ops->preview_enabled) //mDevice 即是通过 hw_get_module() 相关流程进行初始化的设备实例，它的类型是 camera_device_t 。return mDevice->ops->preview_enabled(mDevice); //如果 preview 存在，则返回 true 。return false;}

/** Set the ANativeWindow to which preview frames are sent */status_t setPreviewWindow(const sp<ANativeWindow>& buf){ALOGV("%s(%s) buf %p", __FUNCTION__, mName.string(), buf.get());if (mDevice->ops->set_preview_window) { //通过 mDevice->ops 继续向下调用mPreviewWindow = buf;if (buf != nullptr) {if (mPreviewScalingMode != NOT_SET) {setPreviewScalingMode(mPreviewScalingMode);}if (mPreviewTransform != NOT_SET) {setPreviewTransform(mPreviewTransform);}}mHalPreviewWindow.user = this;ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p", __FUNCTION__,&mHalPreviewWindow, mHalPreviewWindow.user);return mDevice->ops->set_preview_window(mDevice,buf.get() ? &mHalPreviewWindow.nw : 0);}return INVALID_OPERATION;}

/**关于 mDevice，结合 Camera.open() 流程与 hw_get_module() 相关逻辑，可以知道它的逻辑是这样的：在 CameraService 启动时，会调用 onFirstRef() 对 module 进行初始化，获取 module 实例。在 open 过程中，CameraClient 连接 CameraServer 成功时，会实例化 CameraHardwareInterface，并传入 module 实例对其初始化。在初始化过程中，通过 module 实例对应的 open 方法，我们获得一个 device 实例，即 mDevice，这对应了具体的摄像头设备。通过 mDevice 就可以将对应的指令传达到硬件设备。*/status_t startPreview(){ALOGV("%s(%s)", __FUNCTION__, mName.string());if (mDevice->ops->start_preview)return mDevice->ops->start_preview(mDevice);return INVALID_OPERATION;}

typedef struct camera_device { //这里就声明了要追踪的 camera_device_t 。/*** camera_device.common.version must be in the range* HARDWARE_DEVICE_API_VERSION(0,0)-(1,FF). CAMERA_DEVICE_API_VERSION_1_0 is* recommended.*/hw_device_t common;camera_device_ops_t *ops;void *priv;
} camera_device_t;

typedef struct camera_device_ops {int (*set_preview_window)(struct camera_device *,struct preview_stream_ops *window);
​void (*set_callbacks)(struct camera_device *,camera_notify_callback notify_cb,camera_data_callback data_cb,camera_data_timestamp_callback data_cb_timestamp,camera_request_memory get_memory,void *user);
​void (*enable_msg_type)(struct camera_device *, int32_t msg_type);
​void (*disable_msg_type)(struct camera_device *, int32_t msg_type);
​int (*msg_type_enabled)(struct camera_device *, int32_t msg_type);
​/*** Start preview mode.*/int (*start_preview)(struct camera_device *);
​void (*stop_preview)(struct camera_device *);
​    ...
} camera_device_ops_t;

memset(camera_device, 0, sizeof(*camera_device));memset(camera_ops, 0, sizeof(*camera_ops));
​camera_device->base.common.tag = HARDWARE_DEVICE_TAG;camera_device->base.common.version = 0;camera_device->base.common.module = (hw_module_t *)(module);camera_device->base.common.close = camera_device_close;camera_device->base.ops = camera_ops;
​camera_ops->set_preview_window = camera_set_preview_window;camera_ops->set_callbacks = camera_set_callbacks;...*device = &camera_device->base.common;
​// -------- TI specific stuff --------
​camera_device->cameraid = cameraid;

int camera_start_preview(struct camera_device * device)
{CAMHAL_LOG_MODULE_FUNCTION_NAME;
​int rv = -EINVAL;ti_camera_device_t* ti_dev = NULL;
​if(!device)return rv;
​ti_dev = (ti_camera_device_t*) device;
​rv = gCameraHals[ti_dev->cameraid]->startPreview(); //gCameraHals 是 CameraHal * 。
​return rv;
}

status_t CameraHal::startPreview() {LOG_FUNCTION_NAME;
​status_t ret = cameraPreviewInitialization(); //首先调用了 cameraPreviewInitialization() 函数进行初始化。
​if (!mPreviewInitializationDone) return ret;
​mPreviewInitializationDone = false;
​if(mDisplayAdapter.get() != NULL) {CAMHAL_LOGDA("Enabling display");int width, height;mParameters.getPreviewSize(&width, &height);
​
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABSret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview);
#elseret = mDisplayAdapter->enableDisplay(width, height, NULL);
#endif
​if ( ret != NO_ERROR ) {CAMHAL_LOGEA("Couldn't enable display");CAMHAL_ASSERT_X(false,"At this stage mCameraAdapter->mStateSwitchLock is still locked, ""deadlock is guaranteed");
​goto error;}}
​CAMHAL_LOGDA("Starting CameraAdapter preview mode");
​ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW); //通过 CameraAdapter 发送 CAMERA_START_PREVIEW 指令，若成功执行，则完成流程。
​if(ret!=NO_ERROR) {CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");goto error;}CAMHAL_LOGDA("Started preview");
​mPreviewEnabled = true;mPreviewStartInProgress = false;return ret;
​error:
​CAMHAL_LOGEA("Performing cleanup after error");
​//Do all the cleanupfreePreviewBufs();mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);if(mDisplayAdapter.get() != NULL) {mDisplayAdapter->disableDisplay(false);}mAppCallbackNotifier->stop();mPreviewStartInProgress = false;mPreviewEnabled = false;LOG_FUNCTION_NAME_EXIT;
​return ret;
}

...if ( NULL != mCameraAdapter ) {ret = mCameraAdapter->setParameters(mParameters); //通过 Adapter 设置相关参数；}
...///Allocate the preview buffersret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers); //申请 Buffers 空间；
...
if ( NO_ERROR == ret ){//在申请 Buffers 空间成功后设置相应的成员。desc.mBuffers = mPreviewDataBuffers;desc.mOffsets = mPreviewDataOffsets;desc.mFd = mPreviewDataFd;desc.mLength = mPreviewDataLength;desc.mCount = ( size_t ) required_buffer_count;desc.mMaxQueueable = (size_t) required_buffer_count;mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,( int ) &desc);}
...///Start the callback notifierret = mAppCallbackNotifier->start(); //开启回调通知。
....//将 Buffers 对应到相应的回调函数中，以供上层 APP 获取预览所需的数据。mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);

const LUT cameraCommandsUserToHAL[] = {{ "CAMERA_START_PREVIEW",                   CameraAdapter::CAMERA_START_PREVIEW },{ "CAMERA_STOP_PREVIEW",                    CameraAdapter::CAMERA_STOP_PREVIEW },{ "CAMERA_START_VIDEO",                     CameraAdapter::CAMERA_START_VIDEO },{ "CAMERA_STOP_VIDEO",                      CameraAdapter::CAMERA_STOP_VIDEO },....
#endif
};

case CameraAdapter::CAMERA_START_PREVIEW: //BaseCameraAdapter::startPreview() 具体操作在其子类中实现，后面通过子类 V4LCameraAdapter 继续分析。{​CAMHAL_LOGDA("Start Preview");
​if ( ret == NO_ERROR ){ret = setState(operation);}
​if ( ret == NO_ERROR ){ret = startPreview();}
​if ( ret == NO_ERROR ){ret = commitState();}else{ret |= rollbackState();}
​break;
​}

private:
​class PreviewThread : public android::Thread {V4LCameraAdapter* mAdapter; //类 V4LCameraAdapter 继承了 BaseCameraAdapterpublic:PreviewThread(V4LCameraAdapter* hw) : //该线程不断执行 Adapter 中的 previewThread() 函数。Thread(false), mAdapter(hw) { }virtual void onFirstRef() {run("CameraPreviewThread", android::PRIORITY_URGENT_DISPLAY);}virtual bool threadLoop() {mAdapter->previewThread();// loop until we need to quitreturn true;}};
​//Used for calculation of the average frame rate during previewstatus_t recalculateFPS();
​char * GetFrame(int &index);
​int previewThread();

status_t V4LCameraAdapter::startPreview()
{status_t ret = NO_ERROR;
​LOG_FUNCTION_NAME;android::AutoMutex lock(mPreviewBufsLock);
​if(mPreviewing) {ret = BAD_VALUE;goto EXIT;}
​for (int i = 0; i < mPreviewBufferCountQueueable; i++) {​mVideoInfo->buf.index = i;mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
​ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf); //通过 v4lIoctl() 函数从硬件获取需要的数据，并存入 Buffers。if (ret < 0) {CAMHAL_LOGEA("VIDIOC_QBUF Failed");goto EXIT;}nQueued++;}
​ret = v4lStartStreaming();// Create and start preview thread for receiving buffers from V4L Cameraif(!mCapturing) {mPreviewThread = new PreviewThread(this);  //启动一个 PreviewThread，用于接收从 V4L 摄像头设备传回的数据。 CAMHAL_LOGDA("Created preview thread");}
​//Update the flag to indicate we are previewing（设置标志，表明预览功能已开启）mPreviewing = true;mCapturing = false;
​
EXIT:LOG_FUNCTION_NAME_EXIT;return ret;
}

int V4LCameraAdapter::previewThread()
{...convertYUV422ToNV12Tiler ( (unsigned char*)fp, (unsigned char*)y_uv[0], width, height); //获取设备传回的数据，并进行一些格式转换操作.
...//给帧数据进行一些必要的参数设置，如帧大小、时间戳等。frame.mFrameType = CameraFrame::PREVIEW_FRAME_SYNC;frame.mBuffer = buffer;frame.mLength = width*height*3/2;frame.mAlignment = stride;frame.mOffset = 0;frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);frame.mFrameMask = (unsigned int)CameraFrame::PREVIEW_FRAME_SYNC;
...ret = sendFrameToSubscribers(&frame); //将帧数据发送给用户}}
EXIT:return ret;
}

status_t AppCallbackNotifier::startPreviewCallbacks(android::CameraParameters &params, CameraBuffer *buffers, uint32_t *offsets, int fd, size_t length, size_t count)
{
...///Get preview sizeparams.getPreviewSize(&w, &h);
...if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_POSTVIEW_FRAME) ) {mFrameProvider->enableFrameNotification(CameraFrame::SNAPSHOT_FRAME); //同步预览帧}return NO_ERROR;
}

void AppCallbackNotifier::setCallbacks(CameraHal* cameraHal,camera_notify_callback notify_cb,camera_data_callback data_cb,camera_data_timestamp_callback data_cb_timestamp,camera_request_memory get_memory,void *user)
{android::AutoMutex lock(mLock);
​LOG_FUNCTION_NAME;
​mCameraHal = cameraHal;mNotifyCb = notify_cb;mDataCb = data_cb;mDataCbTimestamp = data_cb_timestamp;mRequestMemory = get_memory;mCallbackCookie = user;
​LOG_FUNCTION_NAME_EXIT;
}

case CameraHalEvent::EVENT_METADATA: //预览元数据
​metaEvtData = evt->mEventData->metadataEvent;
​if ( ( NULL != mCameraHal ) &&( NULL != mNotifyCb) &&( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_METADATA) ) ){// WA for an issue inside CameraServicecamera_memory_t *tmpBuffer = mRequestMemory(-1, 1, 1, NULL); //申请一个 camera_memory_t 对应的 Buffers 空间后，就调用回调函数将元数据往上层进行传输了。
​mDataCb(CAMERA_MSG_PREVIEW_METADATA,tmpBuffer,0,metaEvtData->getMetadataResult(),mCallbackCookie);
​metaEvtData.clear();
​if ( NULL != tmpBuffer ) {tmpBuffer->release(tmpBuffer);}
​}
​break;