本文均属自己阅读源码的点滴总结，转账请注明出处谢谢。
欢迎和大家交流。qq:1037701636 email:[email protected]
Android源码版本Version：4.2.2; 硬件平台 全志A31
这里单独以preview的控制和数据流来进行相关的camera的调用处理，主要先引入Camera 的HAL层的处理结构。
调用还是先从camera的JNI和HAL两个方面来分析：
step1：启动预览startPreview()
// start preview modestatus_t Camera::startPreview(){ ALOGV("startPreview"); sp <ICamera> c = mCamera; if (c == 0) return NO_INIT; return c->startPreview();}这里的mCamera是之前connect请求CameraService建立，该类是匿名的BpCamera直接和CameraService处的CameraClient（该类继承了CameraService的内部类Client，Client继承了BnCamera）进行交互。
step2:调用CameraService侧的CameraClient里的startpreview()
status_t CameraClient::startPreviewMode() { LOG1("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) { native_window_set_scaling_mode(mPreviewWindow.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); native_window_set_buffers_transform(mPreviewWindow.get(), mOrientation); } mHardware->setPreviewWindow(mPreviewWindow);//mPreviewWindow为一个本地窗口ANativeWindow result = mHardware->startPreview(); return result;}这里出现了一个mPreviewWIndow对象，其类为ANativeWindow，很熟悉的一个应用端的本地窗口。那么这个窗口的初始化过程呢，即这个变量是哪里来的？
step3:探秘本地预览窗口mPreviewWinodw对象
java处：
public final void setPreviewDisplay(SurfaceHolder holder) throws IOException { if (holder != null) { setPreviewDisplay(holder.getSurface()); } else { setPreviewDisplay((Surface)null); } }这个getSurface()的获取调用如下
static sp<Surface> getSurface(JNIEnv* env, jobject surfaceObj) { sp<Surface> result(android_view_Surface_getSurface(env, surfaceObj)); if (result == NULL) { /* * if this method is called from the WindowManager's process, it means * the client is is not remote, and therefore is allowed to have * a Surface (data), so we create it here. * If we don't have a SurfaceControl, it means we're in a different * process. */ SurfaceControl* const control = reinterpret_cast<SurfaceControl*>( env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurfaceControl)); if (control) { result = control->getSurface(); if (result != NULL) { result->incStrong(surfaceObj); env->SetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurface, reinterpret_cast<jint>(result.get())); } } } return result;}看到这里可以回顾到从Android Bootanimation理解SurfaceFlinger的客户端建立这一文中，对客户端的一个Surface建立，这里的过程几乎一摸一样，最终返回一个客户端需要的Surface用来绘图使用。
而这个surface最终也将进一步传递到JNI，HAL供实时的预览等。
JNI处：
static void android_hardware_Camera_setPreviewDisplay(JNIEnv *env, jobject thiz, jobject jSurface){ ALOGV("setPreviewDisplay"); sp<Camera> camera = get_native_camera(env, thiz, NULL); if (camera == 0) return; sp<Surface> surface = NULL; if (jSurface != NULL) { surface = reinterpret_cast<Surface*>(env->GetIntField(jSurface, fields.surface)); } if (camera->setPreviewDisplay(surface) != NO_ERROR) { jniThrowException(env, "java/io/IOException", "setPreviewDisplay failed"); }}来到JNI层的实现，获取之前由CameraService创作的Camera对象，该类继承了BpCamera用于进一步和CameraService端的CameraClient进行交互。
step4:CameraService处的响应
status_t BnCamera::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){..... case SET_PREVIEW_DISPLAY: { ALOGV("SET_PREVIEW_DISPLAY"); CHECK_INTERFACE(ICamera, data, reply); sp<Surface> surface = Surface::readFromParcel(data); reply->writeInt32(setPreviewDisplay(surface)); return NO_ERROR; } break;...... case START_PREVIEW: { ALOGV("START_PREVIEW"); CHECK_INTERFACE(ICamera, data, reply); reply->writeInt32(startPreview());//调用服务端的cameraclient处的函数，为该类的派生类 return NO_ERROR; } break;}由于之前connect写入的Binder本地实体类对象为CameraClient，则由该类对象的成员函数来实现。
status_t CameraClient::setPreviewDisplay(const sp<Surface>& surface) { LOG1("setPreviewDisplay(%p) (pid %d)", surface.get(), getCallingPid()); sp<IBinder> binder(surface != 0 ? surface->asBinder() : 0); sp<ANativeWindow> window(surface); return setPreviewWindow(binder, window);}再调用SetPreviewWindow(),传入的Binder分别为Surface对象和一个ANativeWindow对象window。status_t CameraClient::setPreviewWindow(const sp<IBinder>& binder, const sp<ANativeWindow>& window) { Mutex::Autolock lock(mLock); status_t result = checkPidAndHardware(); if (result != NO_ERROR) return result; // return if no change in surface. if (binder == mSurface) { return NO_ERROR; } if (window != 0) { result = native_window_api_connect(window.get(), NATIVE_WINDOW_API_CAMERA); if (result != NO_ERROR) { ALOGE("native_window_api_connect failed: %s (%d)", strerror(-result), result); return result; } } // If preview has been already started, register preview buffers now. if (mHardware->previewEnabled()) { if (window != 0) { native_window_set_scaling_mode(window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); native_window_set_buffers_transform(window.get(), mOrientation); result = mHardware->setPreviewWindow(window); } } if (result == NO_ERROR) { // Everything has succeeded. Disconnect the old window and remember the // new window. disconnectWindow(mPreviewWindow); mSurface = binder;// This is a binder of Surface or SurfaceTexture. mPreviewWindow = window;//获取了预览的数据窗口 } else { // Something went wrong after we connected to the new window, so // disconnect here. disconnectWindow(window); } return result;}调用mHardware这个硬件接口将本地的一个Window窗口传递到HAL层。并将这个windw记录到mPreviewWindow中。
Camera的HAL相关的具体实现结构
到了这里已经非讲不可的是mHardware啦，因为这个接口类将不得不访问HAL层。如最之前的result = mHardware->startPreview();函数。
status_t startPreview() { ALOGV("%s(%s)", __FUNCTION__, mName.string()); if (mDevice->ops->start_preview) return mDevice->ops->start_preview(mDevice); return INVALID_OPERATION; }这是一个典型的底层设备的调用。因此将和大家分享Camera的HAL层的相关操作。
1.参考当前平台的Camera源码，CameraService启动时会调用Camera的HAL模块，第一次open操作的最终调用如下：
int HALCameraFactory::device_open(const hw_module_t* module, const char* name, hw_device_t** device)//最先被framework层调用{ /* * Simply verify the parameters, and dispatch the call inside the * HALCameraFactory instance. */..... return gEmulatedCameraFactory.cameraDeviceOpen(atoi(name), device);}该Camera模块中gEmulatedCameraFactory是一个静态的全局对象。来看该对象的构造过程：
HALCameraFactory::HALCameraFactory() : mHardwareCameras(NULL), mAttachedCamerasNum(0), mRemovableCamerasNum(0), mConstructedOK(false){ F_LOG; LOGD("camera hal version: %s", CAMERA_HAL_VERSION); /* Make sure that array is allocated. */ if (mHardwareCameras == NULL) { mHardwareCameras = new CameraHardware*[MAX_NUM_OF_CAMERAS]; if (mHardwareCameras == NULL) { LOGE("%s: Unable to allocate V4L2Camera array for %d entries", __FUNCTION__, MAX_NUM_OF_CAMERAS); return; } memset(mHardwareCameras, 0, MAX_NUM_OF_CAMERAS * sizeof(CameraHardware*)); } /* Create the cameras */ for (int id = 0; id < MAX_NUM_OF_CAMERAS; id++) { // camera config information mCameraConfig[id] = new CCameraConfig(id);//读取camera配置文件.cfg if(mCameraConfig[id] == 0) { LOGW("create CCameraConfig failed"); } else { mCameraConfig[id]->initParameters(); mCameraConfig[id]->dumpParameters(); } mHardwareCameras[id] = new CameraHardware(&HAL_MODULE_INFO_SYM.common, mCameraConfig[id]);//创建CameraHardware if (mHardwareCameras[id] == NULL) { mHardwareCameras--; LOGE("%s: Unable to instantiate fake camera class", __FUNCTION__); return; } } // check camera cfg if (mCameraConfig[0] != NULL) { mAttachedCamerasNum = mCameraConfig[0]->numberOfCamera(); if ((mAttachedCamerasNum == 2) && (mCameraConfig[1] == NULL)) { return; } } mConstructedOK = true;}这个全局对象是新建并初始化CameraHardware对象，而这里的Camera支持数目为2个。CameraHardware表示的是一个完整的摄像头类型，该类继承了camera_device这个结构体类：
CameraHardware::CameraHardware(struct hw_module_t* module, CCameraConfig* pCameraCfg) : mPreviewWindow(), mCallbackNotifier(), mCameraConfig(pCameraCfg), mIsCameraIdle(true), mFirstSetParameters(true), mFullSizeWidth(0), mFullSizeHeight(0), mCaptureWidth(0), mCaptureHeight(0), mVideoCaptureWidth(0), mVideoCaptureHeight(0), mUseHwEncoder(false), mFaceDetection(NULL), mFocusStatus(FOCUS_STATUS_IDLE), mIsSingleFocus(false), mOriention(0), mAutoFocusThreadExit(true), mIsImageCaptureIntent(false){ /* * Initialize camera_device descriptor for this object. */ F_LOG; /* Common header */ common.tag = HARDWARE_DEVICE_TAG; common.version = 0; common.module = module; common.close = CameraHardware::close; /* camera_device fields. */ ops = &mDeviceOps; priv = this; // instance V4L2CameraDevice object mV4L2CameraDevice = new V4L2CameraDevice(this, &mPreviewWindow, &mCallbackNotifier);//初始化V4L2CameraDevice if (mV4L2CameraDevice == NULL) { LOGE("Failed to create V4L2Camera instance"); return ; } memset((void*)mCallingProcessName, 0, sizeof(mCallingProcessName)); memset(&mFrameRectCrop, 0, sizeof(mFrameRectCrop)); memset((void*)mFocusAreasStr, 0, sizeof(mFocusAreasStr)); memset((void*)&mLastFocusAreas, 0, sizeof(mLastFocusAreas)); // init command queue OSAL_QueueCreate(&mQueueCommand, CMD_QUEUE_MAX); memset((void*)mQueueElement, 0, sizeof(mQueueElement)); // init command thread pthread_mutex_init(&mCommandMutex, NULL); pthread_cond_init(&mCommandCond, NULL); mCommandThread = new DoCommandThread(this); mCommandThread->startThread(); // init auto focus thread pthread_mutex_init(&mAutoFocusMutex, NULL); pthread_cond_init(&mAutoFocusCond, NULL); mAutoFocusThread = new DoAutoFocusThread(this);}这里对这个CameraHardware对象进行了成员变量的初始化，其中包括camera_device_t结构体的初始化，其中ops是对Camera模块操作的核心所在。
typedef struct camera_device { /** * 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;这里有出息了一个V4L2CameraDevice对象，真正的和底层内核打交道的地方，基于V4L2的架构实现。
V4L2CameraDevice::V4L2CameraDevice(CameraHardware* camera_hal, PreviewWindow * preview_window, CallbackNotifier * cb) : mCameraHardware(camera_hal),.......{ LOGV("V4L2CameraDevice construct"); memset(&mHalCameraInfo, 0, sizeof(mHalCameraInfo)); memset(&mRectCrop, 0, sizeof(Rect)); // init preview buffer queue OSAL_QueueCreate(&mQueueBufferPreview, NB_BUFFER);//建立10个预览帧 OSAL_QueueCreate(&mQueueBufferPicture, 2);//建立2个图片帧buffer // init capture thread mCaptureThread = new DoCaptureThread(this); pthread_mutex_init(&mCaptureMutex, NULL); pthread_cond_init(&mCaptureCond, NULL); mCaptureThreadState = CAPTURE_STATE_PAUSED; mCaptureThread->startThread();//启动视频采集 // init preview thread mPreviewThread = new DoPreviewThread(this); pthread_mutex_init(&mPreviewMutex, NULL); pthread_cond_init(&mPreviewCond, NULL); mPreviewThread->startThread();//启动预览 // init picture thread mPictureThread = new DoPictureThread(this); pthread_mutex_init(&mPictureMutex, NULL); pthread_cond_init(&mPictureCond, NULL); mPictureThread->startThread();//启动拍照 pthread_mutex_init(&mConnectMutex, NULL); pthread_cond_init(&mConnectCond, NULL); // init continuous picture thread mContinuousPictureThread = new DoContinuousPictureThread(this); pthread_mutex_init(&mContinuousPictureMutex, NULL); pthread_cond_init(&mContinuousPictureCond, NULL); mContinuousPictureThread->startThread();//启动连续拍照}创建预览mQueueBufferPreview队列，初始化并启动了Camera需要的几个线程：视频采集，预览，拍照，以及连续的拍照等。
通过以上的几个对象构造后Camera的硬件信息维护到了全局类HALCameraFactory的mHardwareCameras[id]成员变量当中。
在客户端的connect，最终调用HAL的cameraDeviceOpen打开真正的设备:
int HALCameraFactory::cameraDeviceOpen(int camera_id, hw_device_t** device){..... if (!mHardwareCameras[0]->isCameraIdle() || !mHardwareCameras[1]->isCameraIdle()) { LOGW("camera device is busy, wait a moment"); usleep(500000); } mHardwareCameras[camera_id]->setCameraHardwareInfo(&mHalCameraInfo[camera_id]); if (mHardwareCameras[camera_id]->connectCamera(device) != NO_ERROR)//连接camera硬件设备 { LOGE("%s: Unable to connect camera", __FUNCTION__); return -EINVAL; } if (mHardwareCameras[camera_id]->Initialize() != NO_ERROR) //camera硬件设备参数等初始化 { LOGE("%s: Unable to Initialize camera", __FUNCTION__); return -EINVAL; } return NO_ERROR;}初始化的流程依次调用HAL的HardwareCamera的connectCamera函数，其实这里最终的核心是返回一个camera device给上层调用camera的具体操作:最终将CameraHardware的基类camera_devcie_t返回给device。
status_t CameraHardware::connectCamera(hw_device_t** device){ F_LOG; status_t res = EINVAL; { Mutex::Autolock locker(&mCameraIdleLock); mIsCameraIdle = false; } if (mV4L2CameraDevice != NULL) { res = mV4L2CameraDevice->connectDevice(&mHalCameraInfo); if (res == NO_ERROR) { *device = &common;......}mV4L2CameraDevice->connectDevice()，真正的开启V4l2的相关Camera启动，内部通过openCameraDev来实现
status_t V4L2CameraDevice::connectDevice(HALCameraInfo * halInfo){ F_LOG;..... // open v4l2 camera device int ret = openCameraDev(halInfo);//调用v4l2的camera标准接口 if (ret != OK) { return ret; } memcpy((void*)&mHalCameraInfo, (void*)halInfo, sizeof(HALCameraInfo));.......}openCameraDev()函数内部的实现就是V4L2的典型的API流程，通过ioctl来完成对内核Camera视频采集的驱动的控制。该流程可以参考DM6446的视频前端VPFE驱动之ioctl控制（视频缓存区，CCDC，decoder)解析
int V4L2CameraDevice::openCameraDev(HALCameraInfo * halInfo){ F_LOG; int ret = -1; struct v4l2_input inp; struct v4l2_capability cap; if (halInfo == NULL) { LOGE("error HAL camera info"); return -1; } // open V4L2 device mCameraFd = open(halInfo->device_name, O_RDWR | O_NONBLOCK, 0); if (mCameraFd == -1) { LOGE("ERROR opening %s: %s", halInfo->device_name, strerror(errno)); return -1; } // check v4l2 device capabilities ret = ioctl (mCameraFd, VIDIOC_QUERYCAP, &cap); if (ret < 0) { LOGE("Error opening device: unable to query device."); goto END_ERROR; } if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) { LOGE("Error opening device: video capture not supported."); goto END_ERROR; } if ((cap.capabilities & V4L2_CAP_STREAMING) == 0) { LOGE("Capture device does not support streaming i/o"); goto END_ERROR; } if (!strcmp((char *)cap.driver, "uvcvideo")) { mIsUsbCamera = true; } if (!mIsUsbCamera) { // uvc do not need to set input inp.index = halInfo->device_id; if (-1 == ioctl (mCameraFd, VIDIOC_S_INPUT, &inp)) { LOGE("VIDIOC_S_INPUT error!"); goto END_ERROR; } } // try to support this format: NV21, YUYV.....}到这里为止一共典型的Camera从应用侧到CameraService再到Camera HAL处的初始化流程基本完成。
总结下的是HAL层建立了一个基于V4L2的V4L2CameraDevice对象来完成和内核视频采集模块的互动，返回一个camera_device_t结构体对象mDevice来为后续对Camera设备的进一步控制。