Android Camera数据流分析全程记录（非overlay方式）

Android Camera数据流分析全程记录

花了不少时间在这个数据流的分析上面，自己毕竟没怎么做过android，这里记录一下自己的见解，任何理解错误还望高人指教，以后还需慢慢纠正
整个分析过程从app的onCreate开始：packages/apps/OMAPCamera/src/com/ti/omap4/android/camera/Camera.java
在onCreate中做了很多的初始化，我们真正关注的是一下几条语句：

1. // don't set mSurfaceHolder here. We have it set ONLY within
   
2. // surfaceChanged / surfaceDestroyed, other parts of the code
   
3. // assume that when it is set, the surface is also set.
   
4. SurfaceView preview = (SurfaceView) findViewById(R.id.camera_preview);
   
5. SurfaceHolder holder = preview.getHolder();
   
6. holder.addCallback(this);

在这里我们实例化了一个SurfaceView对象，通过这个对象获取SurfaceHolder对象，实现这个addCallback方法，
其中 SurfaceView的定义在以下路径： frameworks/base/core/java/android/view/SurfaceView.java
其中 SurfaceHolder的定义在以下路径： frameworks/base/core/java/android/view/SurfaceHolder.java

这里看看这个文章的解释，写的很是不错：http://blog.chinaunix.net/uid-9863638-id-1996383.html

SurfaceFlinger 是Android multimedia 的一个部分，在Android 的实现中它是一个service ，提供系统范围内的surface composer 功能，它能够将各种应用程序的2D，3D surface 进行组合。
在具体讲SurfaceFlinger 之前，我们先来看一下有关显示方面的一些基础知识 。

每个应用程序可能对应着一个或者多个图形界面，而每个界面我们就称之为一个surface ，或者说是window ，在上面的图中我们能看到4 个surface ，一个是home 界面，还有就是红、绿、蓝分别代表的3 个surface ，而两个button 实际是home surface 里面的内容。在这里我们能看到我们进行图形显示所需要解决 的问题：
a 、首先每个surface 在屏幕上有它的位置，以及大小，然后每个surface 里面还有要显示的内容，内容，大小，位置 这些元素 在我们改变应用程序的时候都可能会改变，改变时应该如何处理 
b 、然后就各个surface 之间可能有重叠，比如说在上面的简略图中，绿色覆盖了蓝色，而红色又覆盖了绿色和蓝色以及下面的home ，而且还具有一定透明度。这种层之间的关系应该如何描述      
我们首先来看第二个问题，我们可以想象在屏幕平面的垂直方向还有一个Z 轴，所有的surface 根据在Z 轴上的坐标来确定前后，这样就可以描述各个surface 之间的上下覆盖关系了，而这个在Z 轴上的顺序，图形上有个专业术语叫Z-order 。  
对于第一个问题，我们需要一个结构来记录应用程序界面的位置，大小，以及一个buffer 来记录需要显示的内容，所以这就是我们surface 的概念，surface 实际我们可以把它理解成一个容器，这个容器记录着应用程序界面的控制信息，比如说大小啊，位置啊，而它还有buffer 来专门存储需要显示的内容。
在这里还存在一个问题，那就是当存在图形重合的时候应该如何处理呢，而且可能有些surface 还带有透明信息，这里就是我们SurfaceFlinger 需要解决问题，它要把各个surface 组合(compose/merge) 成一个main Surface ，最后将Main Surface 的内容发送给FB/V4l2 Output ，这样屏幕上就能看到我们想要的效果。
在实际中对这些Surface 进行merge 可以采用两种方式，一种就是采用软件的形式来merge ，还一种就是采用硬件的方式，软件的方式就是我们的SurfaceFlinger ，而硬件的方式就是Overlay 。

首先继承SurfaceView并实现SurfaceHolder.Callback接口
使用接口的原因：因为使用SurfaceView 有一个原则，所有的绘图工作必须得在Surface 被创建之后才能开始(Surface—表面，基本上我们可以把它当作显存的一个映射，写入到Surface 的内容可以被直接复制到显存从而显示出来，这使得显示速度会非常快)，而在Surface 被销毁之前必须结束。所以Callback 中的surfaceCreated 和surfaceDestroyed 就成了绘图处理代码的边界。
需要重写的方法
　（1）public void surfaceChanged(SurfaceHolder holder,int format,int width,int height){}//在surface的大小发生改变时激发
　（2）public void surfaceCreated(SurfaceHolder holder){}//在创建时激发，一般在这里调用画图的线程。
　（3）public void surfaceDestroyed(SurfaceHolder holder) {} //销毁时激发，一般在这里将画图的线程停止、释放。
这几个方法在在app中都已经重新实现了，重点分析 surfaceChanged

1. public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
   
2.         // Make sure we have a surface in the holder before proceeding.
   
3.         if (holder.getSurface() == null) {
   
4.             Log.d(TAG, "holder.getSurface() == null");
   
5.             return;
   
6.         }
   
7. 
   
8.         Log.v(TAG, "surfaceChanged. w=" + w + ". h=" + h);
   
9. 
   
10.         // We need to save the holder for later use, even when the mCameraDevice
    
11.         // is null. This could happen if onResume() is invoked after this
    
12.         // function.
    
13.         mSurfaceHolder = holder;
    
14. 
    
15.         // The mCameraDevice will be null if it fails to connect to the camera
    
16.         // hardware. In this case we will show a dialog and then finish the
    
17.         // activity, so it's OK to ignore it.
    
18.         if (mCameraDevice == null) return;
    
19. 
    
20.         // Sometimes surfaceChanged is called after onPause or before onResume.
    
21.         // Ignore it.
    
22.         if (mPausing || isFinishing()) return;
    
23. 
    
24.         setSurfaceLayout();
    
25. 
    
26.         // Set preview display if the surface is being created. Preview was
    
27.         // already started. Also restart the preview if display rotation has
    
28.         // changed. Sometimes this happens when the device is held in portrait
    
29.         // and camera app is opened. Rotation animation takes some time and
    
30.         // display rotation in onCreate may not be what we want.
    
31.         if (mCameraState == PREVIEW_STOPPED) {//这里check摄像头是否已经启动，第一次启动摄像头和摄像头已经打开从新进入摄像头实现方法不同
    
32.             startPreview(true);
    
33.             startFaceDetection();
    
34.         } else {
    
35.             if (Util.getDisplayRotation(this) != mDisplayRotation) {
    
36.                 setDisplayOrientation();
    
37.             }
    
38.             if (holder.isCreating()) {
    
39.                 // Set preview display if the surface is being created and preview
    
40.                 // was already started. That means preview display was set to null
    
41.                 // and we need to set it now.
    
42.                 setPreviewDisplay(holder);
    
43.             }
    
44.         }
    
45. 
    
46.         // If first time initialization is not finished, send a message to do
    
47.         // it later. We want to finish surfaceChanged as soon as possible to let
    
48.         // user see preview first.
    
49.         if (!mFirstTimeInitialized) {
    
50.             mHandler.sendEmptyMessage(FIRST_TIME_INIT);
    
51.         } else {
    
52.             initializeSecondTime();
    
53.         }
    
54. 
    
55.         SurfaceView preview = (SurfaceView) findViewById(R.id.camera_preview);
    
56.         CameraInfo info = CameraHolder.instance().getCameraInfo()[mCameraId];
    
57.         boolean mirror = (info.facing == CameraInfo.CAMERA_FACING_FRONT);
    
58.         int displayRotation = Util.getDisplayRotation(this);
    
59.         int displayOrientation = Util.getDisplayOrientation(displayRotation, mCameraId);
    
60. 
    
61.         mTouchManager.initialize(preview.getHeight() / 3, preview.getHeight() / 3,
    
62.                preview, this, mirror, displayOrientation);
    
63. 
    
64.     }

以上标注部分是关键，现在直接分心startPreview方法，这是第一次打开摄像头的处理函数，进行了一些初始换，而已经处于摄像头打开状态时不必使用startPreview方法，而是用上面的另外一个分支，重新开始显示即可

1. private void startPreview(boolean updateAll) {
   
2.         if (mPausing || isFinishing()) return;
   
3. 
   
4.         mFocusManager.resetTouchFocus();
   
5. 
   
6.         mCameraDevice.setErrorCallback(mErrorCallback);
   
7. 
   
8.         // If we're previewing already, stop the preview first (this will blank
   
9.         // the screen).
   
10.         if (mCameraState != PREVIEW_STOPPED) stopPreview();
    
11. 
    
12.         setPreviewDisplay(mSurfaceHolder);
    
13.         setDisplayOrientation();
    
14. 
    
15.         if (!mSnapshotOnIdle) {
    
16.             // If the focus mode is continuous autofocus, call cancelAutoFocus to
    
17.             // resume it because it may have been paused by autoFocus call.
    
18.             if (Parameters.FOCUS_MODE_CONTINUOUS_PICTURE.equals(mFocusManager.getFocusMode())) {
    
19.                 mCameraDevice.cancelAutoFocus();
    
20.             }
    
21.             mFocusManager.setAeAwbLock(false); // Unlock AE and AWB.
    
22.         }
    
23. 
    
24.         if ( updateAll ) {
    
25.             Log.v(TAG, "Updating all parameters!");
    
26.             setCameraParameters(UPDATE_PARAM_INITIALIZE | UPDATE_PARAM_ZOOM | UPDATE_PARAM_PREFERENCE);
    
27.         } else {
    
28.             setCameraParameters(UPDATE_PARAM_MODE);
    
29.         }
    
30. 
    
31.         //setCameraParameters(UPDATE_PARAM_ALL);
    
32. 
    
33.         // Inform the mainthread to go on the UI initialization.
    
34.         if (mCameraPreviewThread != null) {
    
35.             synchronized (mCameraPreviewThread) {
    
36.                 mCameraPreviewThread.notify();
    
37.             }
    
38.         }
    
39. 
    
40.         try {
    
41.             Log.v(TAG, "startPreview");
    
42.             mCameraDevice.startPreview();
    
43.         } catch (Throwable ex) {
    
44.             closeCamera();
    
45.             throw new RuntimeException("startPreview failed", ex);
    
46.         }
    
47. 
    
48.         mZoomState = ZOOM_STOPPED;
    
49.         setCameraState(IDLE);
    
50.         mFocusManager.onPreviewStarted();
    
51.         if ( mTempBracketingEnabled ) {
    
52.             mFocusManager.setTempBracketingState(FocusManager.TempBracketingStates.ACTIVE);
    
53.         }
    
54. 
    
55.         if (mSnapshotOnIdle) {
    
56.             mHandler.post(mDoSnapRunnable);
    
57.         }
    
58.     }

这里的思路是：先通过 setPreviewDisplay 方法将surface设定为window-player，这个方法会调用到HAL层，进行很重要的初始化，实现数据的回调

这里我必须得着重着重的进行分析，我一直在寻找是什么决定了overlay的使用与不适用，这里就这个 setPreviewDisplay 方法就是“罪魁祸首 ”
在setPreview方法中传入的参数是 surfa ceview ，这个surfa ceview传到底层HAL层是参数形式发生了改变，但是在我的理解下，就是人换衣服一样，
张三今天换了一身衣服，但这个张三跟昨天穿不同衣服的张三是同一个人，到了HAL层这个参数的形式是 preview_stream_ops  ，下面慢慢你就可以知道了，
在camerahal中的 setPreviewDisplay 方法中，是通过判断传下来的的 preview_stream_ops  参数是否为空决定使用overlay还是不适用overlay的，很重要的
这篇文章只是在这里提及一下，下面不会提及overlay的内容，默认是以不适用overlay的方式分析数据流的整个过程的，这里可千万别混淆了
使用overl的数据回流方式将单独作为一章分析，同时会详细分析使用和不适用overlay的最终决定权

流程如下：app-->frameworks-->通过JNI-->camera client--> camera service-->通过hardware-interface -->hal_module-->HAL
这里十分有必要看一下camera service层的调用过程：

1. // set the Surface that the preview will use
   
2. status_t CameraService::Client::setPreviewDisplay(const sp<Surface>& surface) {
   
3.     LOG1("setPreviewDisplay(%p) (pid %d)", surface.get(), getCallingPid());
   
4. 
   
5.     sp<IBinder> binder(surface != 0 ? surface->asBinder() : 0);
   
6.     sp<ANativeWindow> window(surface);
   
7.     return setPreviewWindow(binder, window);
   
8. }

这里其实我还是理解的不是很透彻，将我们从app传进来的surface转换为IBinder和ANativiWindow，然后以这两个变量为参数接着调用参数不同的 setPreviewWindow

1. status_t CameraService::Client::setPreviewWindow(const sp<IBinder>& binder,
   
2.         const sp<ANativeWindow>& window) {
   
3.     Mutex::Autolock lock(mLock);
   
4.     status_t result = checkPidAndHardware();
   
5.     if (result != NO_ERROR) return result;
   
6. 
   
7.     // return if no change in surface.
   
8.     if (binder == mSurface) {
   
9.         return NO_ERROR;
   
10.     }
    
11. 
    
12.     if (window != 0) {
    
13.         result = native_window_api_connect(window.get(), NATIVE_WINDOW_API_CAMERA);
    
14.         if (result != NO_ERROR) {
    
15.             LOGE("native_window_api_connect failed: %s (%d)", strerror(-result),
    
16.                     result);
    
17.             return result;
    
18.         }
    
19.     }
    
20. 
    
21.     // If preview has been already started, register preview buffers now.
    
22.     if (mHardware->previewEnabled()) {
    
23.         if (window != 0) {
    
24.             native_window_set_scaling_mode(window.get(),
    
25.                     NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
    
26.             native_window_set_buffers_transform(window.get(), mOrientation);
    
27.             result = mHardware->setPreviewWindow(window);
    
28.         }
    
29.     }
    
30. 
    
31.     if (result == NO_ERROR) {
    
32.         // Everything has succeeded. Disconnect the old window and remember the
    
33.         // new window.
    
34.         disconnectWindow(mPreviewWindow);
    
35.         mSurface = binder;
    
36.         mPreviewWindow = window;
    
37.     } else {
    
38.         // Something went wrong after we connected to the new window, so
    
39.         // disconnect here.
    
40.         disconnectWindow(window);
    
41.     }
    
42. 
    
43.     return result;
    
44. }

上面先调用到CameraHardwareInterface中的setPreview方法：

1. status_t setPreviewWindow(const sp<ANativeWindow>& buf)
   
2.     {
   
3.         LOGV("%s(%s) buf %p", __FUNCTION__, mName.string(), buf.get());
   
4. 
   
5.         if (mDevice->ops->set_preview_window) {
   
6.             mPreviewWindow = buf;
   
7. #ifdef OMAP_ENHANCEMENT_CPCAM
   
8.             mHalPreviewWindow.user = mPreviewWindow.get();
   
9. #else
   
10.             mHalPreviewWindow.user = this;
    
11. #endif
    
12.             LOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p", __FUNCTION__,
    
13.                     &mHalPreviewWindow, mHalPreviewWindow.user);
    
14.             return mDevice->ops->set_preview_window(mDevice,
    
15.                     buf.get() ? &mHalPreviewWindow.nw : 0);
    
16.         }
    
17.         return INVALID_OPERATION;
    
18.     }

到这里为止，传输的参数已经由最初的surface-->ANativeWindow-->preview_stream_ops, 传递到底层的参数已经发生了本质的变化，后面数据回调的时候还会见到这里变量，现在先记下它
其实我说的本质的变化这里也只能这么说，但往深入追究，这个preview_stream_ops也可以说只是surface的另外一种形式而已
这样才通过hardware调用到hal-module再调用到hal层

1. int camera_set_preview_window(struct camera_device * device,
   
2.         struct preview_stream_ops *window)
   
3. {
   
4.     int rv = -EINVAL;
   
5.     ti_camera_device_t* ti_dev = NULL;
   
6. 
   
7.     LOGV("%s", __FUNCTION__);
   
8. 
   
9.     if(!device)
   
10.         return rv;
    
11. 
    
12.     ti_dev = (ti_camera_device_t*) device;
    
13. 
    
14.     rv = gCameraHals[ti_dev->cameraid]->setPreviewWindow(window);
    
15. 
    
16.     return rv;
    
17. }

HAL层调用：

1. status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window)
   
2. {
   
3.     status_t ret = NO_ERROR;
   
4.     CameraAdapter::BuffersDescriptor desc;
   
5. 
   
6.     LOG_FUNCTION_NAME;
   
7.     mSetPreviewWindowCalled = true;
   
8. 
   
9.    //If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter
   
10.     if(!window)
    
11.     {
    
12.         if(mDisplayAdapter.get() != NULL)
    
13.         {
    
14.             ///NULL window passed, destroy the display adapter if present
    
15.             CAMHAL_LOGD("NULL window passed, destroying display adapter");
    
16.             mDisplayAdapter.clear();
    
17.             ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client
    
18.             ///@remarks so, we will wait until it passes a valid window to begin the preview again
    
19.             mSetPreviewWindowCalled = false;
    
20.         }
    
21.         CAMHAL_LOGD("NULL ANativeWindow passed to setPreviewWindow");
    
22.         return NO_ERROR;
    
23.     }else if(mDisplayAdapter.get() == NULL)
    
24.     {
    
25.         // Need to create the display adapter since it has not been created
    
26.         // Create display adapter
    
27.         mDisplayAdapter = new ANativeWindowDisplayAdapter();
    
28.         ret = NO_ERROR;
    
29.         if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR))
    
30.         {
    
31.             if(ret!=NO_ERROR)
    
32.             {
    
33.                 mDisplayAdapter.clear();
    
34.                 CAMHAL_LOGEA("DisplayAdapter initialize failed");
    
35.                 LOG_FUNCTION_NAME_EXIT;
    
36.                 return ret;
    
37.             }
    
38.             else
    
39.             {
    
40.                 CAMHAL_LOGEA("Couldn't create DisplayAdapter");
    
41.                 LOG_FUNCTION_NAME_EXIT;
    
42.                 return NO_MEMORY;
    
43.             }
    
44.         }
    
45. 
    
46.         // DisplayAdapter needs to know where to get the CameraFrames from inorder to display
    
47.         // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter
    
48.         mDisplayAdapter->setFrameProvider(mCameraAdapter);
    
49. 
    
50.         // Any dynamic errors that happen during the camera use case has to be propagated back to the application
    
51.         // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
    
52.         // Set it as the error handler for the DisplayAdapter
    
53.         mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());
    
54. 
    
55.         // Update the display adapter with the new window that is passed from CameraService
    
56.         ret = mDisplayAdapter->setPreviewWindow(window);
    
57.         if(ret!=NO_ERROR)
    
58.             {
    
59.             CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret);
    
60.             }
    
61. 
    
62.         if(mPreviewStartInProgress)
    
63.         {
    
64.             CAMHAL_LOGDA("setPreviewWindow called when preview running");
    
65.             // Start the preview since the window is now available
    
66.             ret = startPreview();
    
67.         }
    
68.     } else {
    
69.         // Update the display adapter with the new window that is passed from CameraService
    
70.         ret = mDisplayAdapter->setPreviewWindow(window);
    
71.         if ( (NO_ERROR == ret) && previewEnabled() ) {
    
72.             restartPreview();
    
73.         } else if (ret == ALREADY_EXISTS) {
    
74.             // ALREADY_EXISTS should be treated as a noop in this case
    
75.             ret = NO_ERROR;
    
76.         }
    
77.     }
    
78.     LOG_FUNCTION_NAME_EXIT;
    
79. 
    
80.     return ret;
    
81. 
    
82. }

这里配置好显示数据来源，显示到目标，以及错误信息回调方法，最终开始preview

1. status_t CameraHal::startPreview() {
   
2.     LOG_FUNCTION_NAME;
   
3. 
   
4.     // When tunneling is enabled during VTC, startPreview happens in 2 steps:
   
5.     // When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION,
   
6.     // cameraPreviewInitialization() is called, which in turn causes the CameraAdapter
   
7.     // to move from loaded to idle state. And when the application calls startPreview,
   
8.     // the CameraAdapter moves from idle to executing state.
   
9.     //
   
10.     // If the application calls startPreview() without sending the command
    
11.     // CAMERA_CMD_PREVIEW_INITIALIZATION, then the function cameraPreviewInitialization()
    
12.     // AND startPreview() are executed. In other words, if the application calls
    
13.     // startPreview() without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION,
    
14.     // then the CameraAdapter moves from loaded to idle to executing state in one shot.
    
15.     status_t ret = cameraPreviewInitialization();这个地方十分重要，下面会具体分析
    
16. 
    
17.     // The flag mPreviewInitializationDone is set to true at the end of the function
    
18.     // cameraPreviewInitialization(). Therefore, if everything goes alright, then the
    
19.     // flag will be set. Sometimes, the function cameraPreviewInitialization() may
    
20.     // return prematurely if all the resources are not available for starting preview.
    
21.     // For example, if the preview window is not set, then it would return NO_ERROR.
    
22.     // Under such circumstances, one should return from startPreview as well and should
    
23.     // not continue execution. That is why, we check the flag and not the return value.
    
24.     if (!mPreviewInitializationDone) return ret;
    
25. 
    
26.     // Once startPreview is called, there is no need to continue to remember whether
    
27.     // the function cameraPreviewInitialization() was called earlier or not. And so
    
28.     // the flag mPreviewInitializationDone is reset here. Plus, this preserves the
    
29.     // current behavior of startPreview under the circumstances where the application
    
30.     // calls startPreview twice or more.
    
31.     mPreviewInitializationDone = false;
    
32. 
    
33.     //Enable the display adapter if present, actual overlay enable happens when we post the buffer这里说overlay happens,我一直在找的地方，上面棕色标注将来会在详细说说这里
    
34.     if(mDisplayAdapter.get() != NULL) {
    
35.         CAMHAL_LOGDA("Enabling display");
    
36.         int width, height;
    
37.         mParameters.getPreviewSize(&width, &height);
    
38. 
    
39. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
    
40.         ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview);
    
41. #else
    
42.         ret = mDisplayAdapter->enableDisplay(width, height, NULL);
    
43. #endif
    
44. 
    
45.         if ( ret != NO_ERROR ) {
    
46.             CAMHAL_LOGEA("Couldn't enable display");
    
47. 
    
48.             // FIXME: At this stage mStateSwitchLock is locked and unlock is supposed to be called
    
49.             // only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW)
    
50.             // below. But this will never happen because of goto error. Thus at next
    
51.             // startPreview() call CameraHAL will be deadlocked.
    
52.             // Need to revisit mStateSwitch lock, for now just abort the process.
    
53.             CAMHAL_ASSERT_X(false,
    
54.                 "At this stage mCameraAdapter->mStateSwitchLock is still locked, "
    
55.                 "deadlock is guaranteed");
    
56. 
    
57.             goto error;
    
58.         }
    
59. 
    
60.     }
    
61. 
    
62.     CAMHAL_LOGDA("Starting CameraAdapter preview mode");
63.     //Send START_PREVIEW command to adapter
    
64.     ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);//从这里开始调用到BaseCameraAdapter
    
65. 
    
66.     if(ret!=NO_ERROR) {
    
67.         CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
    
68.         goto error;
    
69.     }
    
70.     CAMHAL_LOGDA("Started preview");
    
71. 
    
72.     mPreviewEnabled = true;
    
73.     mPreviewStartInProgress = false;
    
74.     return ret;
    
75. 
    
76.     error:
    
77. 
    
78.         CAMHAL_LOGEA("Performing cleanup after error");
    
79. 
    
80.         //Do all the cleanup
    
81.         freePreviewBufs();
    
82.         mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
    
83.         if(mDisplayAdapter.get() != NULL) {
    
84.             mDisplayAdapter->disableDisplay(false);
    
85.         }
    
86.         mAppCallbackNotifier->stop();
    
87.         mPreviewStartInProgress = false;
    
88.         mPreviewEnabled = false;
    
89.         LOG_FUNCTION_NAME_EXIT;
    
90. 
    
91.         return ret;
    
92. }

BaseCameraAdapter实现了父类的sendcommand方法：

1. case CameraAdapter::CAMERA_START_PREVIEW:
   
2.             {
   
3. 
   
4.                 CAMHAL_LOGDA("Start Preview");
   
5. 
   
6.             if ( ret == NO_ERROR )
   
7.                 {
   
8.                 ret = setState(operation);
   
9.                 }
   
10. 
    
11.             if ( ret == NO_ERROR )
    
12.                 {
    
13.                 ret = startPreview();
    
14.                 }
    
15. 
    
16.             if ( ret == NO_ERROR )
    
17.                 {
    
18.                 ret = commitState();
    
19.                 }
    
20.             else
    
21.                 {
    
22.                 ret |= rollbackState();
    
23.                 }
    
24. 
    
25.             break;
    
26. 
    
27.             }

这里我们接着分析startPreview方法，之前的文章中已经分析过，这里调用的startPreview方法不是BaseCameraAdapter中的startPreview,而是调用的V4LCameraAdapter中的startPreview方法：

1. status_t V4LCameraAdapter::startPreview()
   
2. {
   
3.     status_t ret = NO_ERROR;
   
4. 
   
5.     LOG_FUNCTION_NAME;
   
6.     Mutex::Autolock lock(mPreviewBufsLock);
   
7. 
   
8.     if(mPreviewing) {
   
9.         ret = BAD_VALUE;
   
10.         goto EXIT;
    
11.     }
    
12. 
    
13.     for (int i = 0; i < mPreviewBufferCountQueueable; i++) {
    
14. 
    
15.         mVideoInfo->buf.index = i;
    
16.         mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
17.         mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
    
18. 
    
19.         ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);//申请内存空间
    
20.         if (ret < 0) {
    
21.             CAMHAL_LOGEA("VIDIOC_QBUF Failed");
    
22.             goto EXIT;
    
23.         }
    
24.         nQueued++;
    
25.     }
    
26. 
    
27.     ret = v4lStartStreaming();
    
28. 
    
29.     // Create and start preview thread for receiving buffers from V4L Camera
    
30.     if(!mCapturing) {
    
31.         mPreviewThread = new PreviewThread(this);//开始preview线程
    
32.         CAMHAL_LOGDA("Created preview thread");
    
33.     }
    
34. 
    
35.     //Update the flag to indicate we are previewing
    
36.     mPreviewing = true;
    
37.     mCapturing = false;
    
38. 
    
39. EXIT:
    
40.     LOG_FUNCTION_NAME_EXIT;
    
41.     return ret;
    
42. }

1. status_t V4LCameraAdapter::v4lStartStreaming () {
   
2.     status_t ret = NO_ERROR;
   
3.     enum v4l2_buf_type bufType;
   
4. 
   
5.     if (!mVideoInfo->isStreaming) {
   
6.         bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
7. 
   
8.         ret = v4lIoctl (mCameraHandle, VIDIOC_STREAMON, &bufType);开始preview
   
9.         if (ret < 0) {
   
10.             CAMHAL_LOGEB("StartStreaming: Unable to start capture: %s", strerror(errno));
    
11.             return ret;
    
12.         }
    
13.         mVideoInfo->isStreaming = true;
    
14.     }
    
15.     return ret;
    
16. }

现在我们就看看开启的preview线程都在干什么：

1. int V4LCameraAdapter::previewThread()
   
2. {
   
3.     status_t ret = NO_ERROR;
   
4.     int width, height;
   
5.     CameraFrame frame;
   
6.     void *y_uv[2];
   
7.     int index = 0;
   
8.     int stride = 4096;
   
9.     char *fp = NULL;
   
10. 
    
11.     mParams.getPreviewSize(&width, &height);
    
12. 
    
13.     if (mPreviewing) {
    
14. 
    
15.         fp = this->GetFrame(index);
    
16.         if(!fp) {
    
17.             ret = BAD_VALUE;
    
18.             goto EXIT;
    
19.         }
    
20.         CameraBuffer *buffer = mPreviewBufs.keyAt(index);
    
21.         CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(buffer);
    
22.         if (!lframe) {
    
23.             ret = BAD_VALUE;
    
24.             goto EXIT;
    
25.         }
    
26. 
    
27.         debugShowFPS();
    
28. 
    
29.         if ( mFrameSubscribers.size() == 0 ) {
    
30.             ret = BAD_VALUE;
    
31.             goto EXIT;
    
32.         }
    
33.         //从这里开始以我的理解是进行数据的转换和保存操作
    
34.         y_uv[0] = (void*) lframe->mYuv[0];
    
35.         //y_uv[1] = (void*) lframe->mYuv[1];
    
36.         //y_uv[1] = (void*) (lframe->mYuv[0] + height*stride);
    
37.         convertYUV422ToNV12Tiler ( (unsigned char*)fp, (unsigned char*)y_uv[0], width, height);
    
38.         CAMHAL_LOGVB("##...index= %d.;camera buffer= 0x%x; y= 0x%x; UV= 0x%x.",index, buffer, y_uv[0], y_uv[1] );
    
39. 
    
40. #ifdef SAVE_RAW_FRAMES
    
41.         unsigned char* nv12_buff = (unsigned char*) malloc(width*height*3/2);
    
42.         //Convert yuv422i to yuv420sp(NV12) & dump the frame to a file
    
43.         convertYUV422ToNV12 ( (unsigned char*)fp, nv12_buff, width, height);
    
44.         saveFile( nv12_buff, ((width*height)*3/2) );
    
45.         free (nv12_buff);
    
46. #endif
    
47. 
    
48.         frame.mFrameType = CameraFrame::PREVIEW_FRAME_SYNC;
    
49.         frame.mBuffer = buffer;
    
50.         frame.mLength = width*height*3/2;
    
51.         frame.mAlignment = stride;
    
52.         frame.mOffset = 0;
    
53.         frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
    
54.         frame.mFrameMask = (unsigned int)CameraFrame::PREVIEW_FRAME_SYNC;
    
55. 
    
56.         if (mRecording)
    
57.         {
    
58.             frame.mFrameMask |= (unsigned int)CameraFrame::VIDEO_FRAME_SYNC;
    
59.             mFramesWithEncoder++;
    
60.         }
    
61. 
    
62.         ret = setInitFrameRefCount(frame.mBuffer, frame.mFrameMask);
    
63.         if (ret != NO_ERROR) {
    
64.             CAMHAL_LOGDB("Error in setInitFrameRefCount %d", ret);
    
65.         } else {
    
66.             ret = sendFrameToSubscribers(&frame);
    
67.         }
    
68.     }
    
69. EXIT:
    
70. 
    
71.     return ret;
    
72. }

就上面这段代码做一下说明，这里在我看来就是整个数据回流过程的中转站了，上面棕色部分buffer中拿到就就是底层driver返回回来的视频数据了，
那么我不是很明白的是，driver中的视频数据是怎么和 mPreviewBufs 还有index关联在一起的，并且这里可以通过 buffer  =  mPreviewBufs . keyAt ( index ) 获取到CameraBuffer，这里待会会详细探究一下
先接着往下说，获取到视频数据之后，如果需要，会将数据经过转换保存到file中方便之后使用，
最后使用得到的camerabuffer填充CameraFrame，这个结构至关重要，在我的理解，最终是通过 sendFrameToSubscribers ( & frame ) ; 方法将数据回流的

这里就先追踪一下 driver中的视频数据是怎么和 mPreviewBufs 还有index关联在一起的
到了这里就不得不提及上面已经说的一个很重要的方法，先看看这个方法：
他是startPreview的第一步， cameraPreviewInitialization

1. status_t CameraHal::cameraPreviewInitialization()
   
2. {
   
3. 
   
4.     status_t ret = NO_ERROR;
   
5.     CameraAdapter::BuffersDescriptor desc;
   
6.     CameraFrame frame;
   
7.     unsigned int required_buffer_count;
   
8.     unsigned int max_queueble_buffers;
   
9. 
   
10. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
    
11.         gettimeofday(&mStartPreview, NULL);
    
12. #endif
    
13. 
    
14.     LOG_FUNCTION_NAME;
    
15. 
    
16.     if (mPreviewInitializationDone) {
    
17.         return NO_ERROR;
    
18.     }
    
19. 
    
20.     if ( mPreviewEnabled ){
    
21.       CAMHAL_LOGDA("Preview already running");
    
22.       LOG_FUNCTION_NAME_EXIT;
    
23.       return ALREADY_EXISTS;
    
24.     }
    
25. 
    
26.     if ( NULL != mCameraAdapter ) {
    
27.       ret = mCameraAdapter->setParameters(mParameters);配置参数到CameraAdapter
    
28.     }
    
29. 
    
30.     if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){
    
31.       ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame);//通过这个command获取frame
    
32.       if ( NO_ERROR != ret ){
    
33.         CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret);
    
34.         return ret;
    
35.       }
    
36. 
    
37.       ///Update the current preview width and height
    
38.       mPreviewWidth = frame.mWidth;//初始化宽和高
    
39.       mPreviewHeight = frame.mHeight;
    
40.     }
    
41. 
    
42.     ///If we don't have the preview callback enabled and display adapter,
    
43.     if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){
    
44.       CAMHAL_LOGD("Preview not started. Preview in progress flag set");
    
45.       mPreviewStartInProgress = true;
    
46.       ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
    
47.       if ( NO_ERROR != ret ){
    
48.         CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret);
    
49.         return ret;
    
50.       }
    
51.       return NO_ERROR;
    
52.     }
    
53. 
    
54.     if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
    
55.         {
    
56.         CAMHAL_LOGDA("Preview is in paused state");
    
57. 
    
58.         mDisplayPaused = false;
    
59.         mPreviewEnabled = true;
    
60.         if ( NO_ERROR == ret )
    
61.             {
    
62.             ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
    
63. 
    
64.             if ( NO_ERROR != ret )
    
65.                 {
    
66.                 CAMHAL_LOGEB("Display adapter resume failed %x", ret);
    
67.                 }
    
68.             }
    
69.         //restart preview callbacks
    
70.         if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
    
71.         {
    
72.             mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);//
    
73.         }
    
74. 
    
75.         signalEndImageCapture();
    
76.         return ret;
    
77.         }
    
78. 
    
79.     required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
    
80. 
    
81.     ///Allocate the preview buffers
    
82.     ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);
    
83. 
    
84.     if ( NO_ERROR != ret )
    
85.         {
    
86.         CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
    
87.         goto error;
    
88.         }
    
89. 
    
90.     if ( mMeasurementEnabled )
    
91.         {
    
92. 
    
93.         ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
    
94.                                           ( int ) &frame,
    
95.                                           required_buffer_count);
    
96.         if ( NO_ERROR != ret )
    
97.             {
    
98.             return ret;
    
99.             }
    
100. 
     
101.          ///Allocate the preview data buffers
     
102.         ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
     
103.         if ( NO_ERROR != ret ) {
     
104.             CAMHAL_LOGEA("Couldn't allocate preview data buffers");
     
105.             goto error;
     
106.            }
     
107. 
     
108.         if ( NO_ERROR == ret )
     
109.             {
     
110.             desc.mBuffers = mPreviewDataBuffers;
     
111.             desc.mOffsets = mPreviewDataOffsets;
     
112.             desc.mFd = mPreviewDataFd;
     
113.             desc.mLength = mPreviewDataLength;
     
114.             desc.mCount = ( size_t ) required_buffer_count;
     
115.             desc.mMaxQueueable = (size_t) required_buffer_count;
     
116. 
     
117.             mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
     
118.                                         ( int ) &desc);
     
119.             }
     
120. 
     
121.         }
     
122. 
     
123.     ///Pass the buffers to Camera Adapter
     
124.     desc.mBuffers = mPreviewBuffers;
     
125.     desc.mOffsets = mPreviewOffsets;
     
126.     desc.mFd = mPreviewFd;
     
127.     desc.mLength = mPreviewLength;
     
128.     desc.mCount = ( size_t ) required_buffer_count;
     
129.     desc.mMaxQueueable = (size_t) max_queueble_buffers;
     
130. 
     
131.     ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,( int ) &desc);
132. 
     
133.     if ( NO_ERROR != ret )
     
134.         {
     
135.         CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret);
     
136.         freePreviewBufs();
     
137.         return ret;
     
138.         }
     
139. 
     
140.     mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBuffers, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);
141.     ///Start the callback notifier
     
142.     ret = mAppCallbackNotifier->start();
     
143. 
     
144.     if( ALREADY_EXISTS == ret )
     
145.         {
     
146.         //Already running, do nothing
     
147.         CAMHAL_LOGDA("AppCallbackNotifier already running");
     
148.         ret = NO_ERROR;
     
149.         }
     
150.     else if ( NO_ERROR == ret ) {
     
151.         CAMHAL_LOGDA("Started AppCallbackNotifier..");
     
152.         mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
     
153.         }
     
154.     else
     
155.         {
     
156.         CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
     
157.         goto error;
     
158.         }
     
159. 
     
160.     if (ret == NO_ERROR) mPreviewInitializationDone = true;
     
161.     return ret;
     
162. 
     
163.     error:
     
164. 
     
165.         CAMHAL_LOGEA("Performing cleanup after error");
     
166. 
     
167.         //Do all the cleanup
     
168.         freePreviewBufs();
     
169.         mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
     
170.         if(mDisplayAdapter.get() != NULL)
     
171.             {
     
172.             mDisplayAdapter->disableDisplay(false);
     
173.             }
     
174.         mAppCallbackNotifier->stop();
     
175.         mPreviewStartInProgress = false;
     
176.         mPreviewEnabled = false;
     
177.         LOG_FUNCTION_NAME_EXIT;
     
178. 
     
179.         return ret;
     
180. }

这里先为preview buffer申请内存，并将preview set进cameraAdapter通过方法 mCameraAdapter - > sendCommand ( CameraAdapter : : CAMERA_USE_BUFFERS_PREVIEW , (   int   )   & desc )
在sendcommand中实现如下：

1.             case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW:
   
2.                 CAMHAL_LOGDA("Use buffers for preview");
   
3.                 desc = ( BuffersDescriptor * ) value1;
   
4. 
   
5.                 if ( NULL == desc )
   
6.                     {
   
7.                     CAMHAL_LOGEA("Invalid preview buffers!");
   
8.                     return -EINVAL;
   
9.                     }
   
10. 
    
11.                 if ( ret == NO_ERROR )
    
12.                     {
    
13.                     ret = setState(operation);
    
14.                     }
    
15. 
    
16.                 if ( ret == NO_ERROR )
    
17.                     {
    
18.                     Mutex::Autolock lock(mPreviewBufferLock);
    
19.                     mPreviewBuffers = desc->mBuffers;
    
20.                     mPreviewBuffersLength = desc->mLength;
    
21.                     mPreviewBuffersAvailable.clear();
    
22.                     mSnapshotBuffersAvailable.clear();
    
23.                     for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ )
    
24.                         {
    
25.                         mPreviewBuffersAvailable.add(&mPreviewBuffers[i], 0);这里实现了mPreviewBuffersAvailable与mPreviewBuffers的关联
    
26.                         }
    
27.                     // initial ref count for undeqeueued buffers is 1 since buffer provider
    
28.                     // is still holding on to it
    
29.                     for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ )
    
30.                         {
    
31.                         mPreviewBuffersAvailable.add(&mPreviewBuffers[i], 1);
    
32.                         }
    
33.                     }
    
34. 
    
35.                 if ( NULL != desc )
    
36.                     {
    
37.                     ret = useBuffers(CameraAdapter::CAMERA_PREVIEW,
    
38.                                      desc->mBuffers,
    
39.                                      desc->mCount,
    
40.                                      desc->mLength,
    
41.                                      desc->mMaxQueueable);
    
42.                     }
    
43. 
    
44.                 if ( ret == NO_ERROR )
    
45.                     {
    
46.                     ret = commitState();
    
47.                     }
    
48.                 else
    
49.                     {
    
50.                     ret |= rollbackState();
    
51.                     }
    
52. 
    
53.                 break;

调用V4LCameraAdapter中的useBuffers方法，然后他会接着调用UseBuffersPreview方法：

1. status_t V4LCameraAdapter::UseBuffersPreview(CameraBuffer *bufArr, int num)
   
2. {
   
3.     int ret = NO_ERROR;
   
4.     LOG_FUNCTION_NAME;
   
5. 
   
6.     if(NULL == bufArr) {
   
7.         ret = BAD_VALUE;
   
8.         goto EXIT;
   
9.     }
   
10. 
    
11.     ret = v4lInitMmap(num);
    
12.     if (ret == NO_ERROR) {
    
13.         for (int i = 0; i < num; i++) {
    
14.             //Associate each Camera internal buffer with the one from Overlay
    
15.             mPreviewBufs.add(&bufArr[i], i);//这里实现了mPreviewBufs和desc->mBuffers的关联
    
16.             CAMHAL_LOGDB("Preview- buff [%d] = 0x%x ",i, mPreviewBufs.keyAt(i));
    
17.         }
    
18. 
    
19.         // Update the preview buffer count
    
20.         mPreviewBufferCount = num;
    
21.     }
    
22. EXIT:
    
23.     LOG_FUNCTION_NAME_EXIT;
    
24.     return ret;
    
25. }

在这里我们还是很有必要去深入研究一下 mAppCallbackNotifier 这个变量的初始化过程，他决定很多回调函数的初始化
的初始化是在哪里实现的呢？？在在camerahal文件的initial中初始化的

1. /**
   
2.    @brief Initialize the Camera HAL
   
3. 
   
4.    Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager
   
5. 
   
6.    @param None
   
7.    @return NO_ERROR - On success
   
8.          NO_MEMORY - On failure to allocate memory for any of the objects
   
9.    @remarks Camera Hal internal function
   
10. 
    
11.  */
    
12. 
    
13. status_t CameraHal::initialize(CameraProperties::Properties* properties)
    
14. {
    
15.     LOG_FUNCTION_NAME;
    
16. 
    
17.     int sensor_index = 0;
    
18.     const char* sensor_name = NULL;
    
19. 
    
20.     ///Initialize the event mask used for registering an event provider for AppCallbackNotifier
    
21.     ///Currently, registering all events as to be coming from CameraAdapter
    
22.     int32_t eventMask = CameraHalEvent::ALL_EVENTS;
    
23. 
    
24.     // Get my camera properties
    
25.     mCameraProperties = properties;
    
26. 
    
27.     if(!mCameraProperties)
    
28.     {
    
29.         goto fail_loop;
    
30.     }
    
31. 
    
32.     // Dump the properties of this Camera
    
33.     // will only print if DEBUG macro is defined
    
34.     mCameraProperties->dump();
    
35. 
    
36.     if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
    
37.         {
    
38.         sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
    
39.         }
    
40. 
    
41.     if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_NAME)) != 0 ) {
    
42.         sensor_name = mCameraProperties->get(CameraProperties::CAMERA_NAME);
    
43.     }
    
44.     CAMHAL_LOGDB("Sensor index= %d; Sensor name= %s", sensor_index, sensor_name);
    
45. 
    
46.     if (strcmp(sensor_name, V4L_CAMERA_NAME_USB) == 0) {
    
47. #ifdef V4L_CAMERA_ADAPTER
    
48.         mCameraAdapter = V4LCameraAdapter_Factory(sensor_index);
    
49. #endif
    
50.     }
    
51.     else {
    
52. #ifdef OMX_CAMERA_ADAPTER
    
53.         mCameraAdapter = OMXCameraAdapter_Factory(sensor_index);
    
54. #endif
    
55.     }
    
56. 
    
57.     if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR))
    
58.         {
    
59.         CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
    
60.         mCameraAdapter = NULL;
    
61.         goto fail_loop;
    
62.         }
    
63. 
    
64.     mCameraAdapter->incStrong(mCameraAdapter);
    
65.     mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
    
66.     mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
    
67. 
    
68.     if(!mAppCallbackNotifier.get())
    
69.         {
    
70.         /// Create the callback notifier
    
71.         mAppCallbackNotifier = new AppCallbackNotifier();
    
72.         if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
    
73.             {
    
74.             CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
    
75.             goto fail_loop;
    
76.             }
    
77.         }
    
78. 
    
79.     if(!mMemoryManager.get())
    
80.         {
    
81.         /// Create Memory Manager
    
82.         mMemoryManager = new MemoryManager();
    
83.         if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
    
84.             {
    
85.             CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
    
86.             goto fail_loop;
    
87.             }
    
88.         }
    
89. 
    
90.     ///Setup the class dependencies...
    
91. 
    
92.     ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
    
93.     ///CameraAdapter is the one which provides those events
    
94.     ///Set it as the frame and event providers for AppCallbackNotifier
    
95.     ///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events
    
96.     /// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
    
97.     /// for any event
    
98.     mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
    
99.     mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
    
100. 
     
101.     ///Any dynamic errors that happen during the camera use case has to be propagated back to the application
     
102.     ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
     
103.     ///Set it as the error handler for CameraAdapter
     
104.     mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
     
105. 
     
106.     ///Start the callback notifier
     
107.     if(mAppCallbackNotifier->start() != NO_ERROR)
     
108.       {
     
109.         CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
     
110.         goto fail_loop;
     
111.       }
     
112. 
     
113.     CAMHAL_LOGDA("Started AppCallbackNotifier..");
     
114.     mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
     
115. 
     
116.     ///Initialize default parameters
     
117.     initDefaultParameters();
     
118. 
     
119. 
     
120.     if ( setParameters(mParameters) != NO_ERROR )
     
121.         {
     
122.         CAMHAL_LOGEA("Failed to set default parameters?!");
     
123.         }
     
124. 
     
125.     // register for sensor events
     
126.     mSensorListener = new SensorListener();
     
127.     if (mSensorListener.get()) {
     
128.         if (mSensorListener->initialize() == NO_ERROR) {
     
129.             mSensorListener->setCallbacks(orientation_cb, this);
     
130.             mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
     
131.         } else {
     
132.             CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
     
133.             mSensorListener.clear();
     
134.             mSensorListener = NULL;
     
135.         }
     
136.     }
     
137. 
     
138.     LOG_FUNCTION_NAME_EXIT;
     
139. 
     
140.     return NO_ERROR;
     
141. 
     
142.     fail_loop:
     
143. 
     
144.         ///Free up the resources because we failed somewhere up
     
145.         deinitialize();
     
146.         LOG_FUNCTION_NAME_EXIT;
     
147. 
     
148.         return NO_MEMORY;
     
149. 
     
150. }

这里实例化了一些对象，我真正关注的是 mAppCallbackNotifier 这个对象，实例化这个对象，并且initialize，并且设置EventProvider和FrameProvider
我们就看一下setFrameProvider这个方法都做了什么事情，

1. void AppCallbackNotifier::setFrameProvider(FrameNotifier *frameNotifier)
   
2. {
   
3.     LOG_FUNCTION_NAME;
   
4.     ///@remarks There is no NULL check here. We will check
   
5.     ///for NULL when we get the start command from CameraAdapter
   
6.     mFrameProvider = new FrameProvider(frameNotifier, this, frameCallbackRelay);
   
7.     if ( NULL == mFrameProvider )
   
8.         {
   
9.         CAMHAL_LOGEA("Error in creating FrameProvider");
   
10.         }
    
11.     else
    
12.         {
    
13.         //Register only for captured images and RAW for now
    
14.         //TODO: Register for and handle all types of frames
    
15.         mFrameProvider->enableFrameNotification(CameraFrame::IMAGE_FRAME);
    
16.         mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
    
17.         }
    
18. 
    
19.     LOG_FUNCTION_NAME_EXIT;
    
20. }

实例化一个FrameProvider对象，并且enable响应notification，这里实例化的对象里面的参数中有一个frameCallbackRely是一个回调函数，这里我们暂且回过头看看previewthread中的那个方法 sendFrameToSubscribers
这个方法只是调用了下面这个方法实现：

1. status_t BaseCameraAdapter::__sendFrameToSubscribers(CameraFrame* frame,
   
2.                                                      KeyedVector<int, frame_callback> *subscribers,
   
3.                                                      CameraFrame::FrameType frameType)
   
4. {
   
5.     size_t refCount = 0;
   
6.     status_t ret = NO_ERROR;
   
7.     frame_callback callback = NULL;
   
8. 
   
9.     frame->mFrameType = frameType;
   
10. 
    
11.     if ( (frameType == CameraFrame::PREVIEW_FRAME_SYNC) ||
    
12.          (frameType == CameraFrame::VIDEO_FRAME_SYNC) ||
    
13.          (frameType == CameraFrame::SNAPSHOT_FRAME) ){
    
14.         if (mFrameQueue.size() > 0){
    
15.           CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(frame->mBuffer);
    
16.           frame->mYuv[0] = lframe->mYuv[0];
    
17.           frame->mYuv[1] = frame->mYuv[0] + (frame->mLength + frame->mOffset)*2/3;
    
18.         }
    
19.         else{
    
20.           CAMHAL_LOGDA("Empty Frame Queue");
    
21.           return -EINVAL;
    
22.         }
    
23.       }
    
24. 
    
25.     if (NULL != subscribers) {
    
26.         refCount = getFrameRefCount(frame->mBuffer, frameType);
    
27. 
    
28.         if (refCount == 0) {
    
29.             CAMHAL_LOGDA("Invalid ref count of 0");
    
30.             return -EINVAL;
    
31.         }
    
32. 
    
33.         if (refCount > subscribers->size()) {
    
34.             CAMHAL_LOGEB("Invalid ref count for frame type: 0x%x", frameType);
    
35.             return -EINVAL;
    
36.         }
    
37. 
    
38.         CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
    
39.                      frame->mFrameType,
    
40.                      ( uint32_t ) frame->mBuffer,
    
41.                      refCount);
    
42. 
    
43.         for ( unsigned int i = 0 ; i < refCount; i++ ) {
    
44.             frame->mCookie = ( void * ) subscribers->keyAt(i);
    
45.             callback = (frame_callback) subscribers->valueAt(i);
    
46. 
    
47.             if (!callback) {
    
48.                 CAMHAL_LOGEB("callback not set for frame type: 0x%x", frameType);
    
49.                 return -EINVAL;
    
50.             }
    
51. 
    
52.             callback(frame);
    
53.         }
    
54.     } else {
    
55.         CAMHAL_LOGEA("Subscribers is null??");
    
56.         return -EINVAL;
    
57.     }
    
58. 
    
59.     return ret;
    
60. }

最重要的部分我在上面已经表示出来，通过subscribers这个全局KeyedVector变量找到相应的frame->mCookie和callback方法，
这里所要获取到的callback方法就是上面setFrameProvider时引入的 frameCallbackRelay 这个函数，我们看看这个函数的具体实现

1. void AppCallbackNotifier::frameCallbackRelay(CameraFrame* caFrame)
   
2. {
   
3.     LOG_FUNCTION_NAME;
   
4.     AppCallbackNotifier *appcbn = (AppCallbackNotifier*) (caFrame->mCookie);
   
5.     appcbn->frameCallback(caFrame);
   
6.     LOG_FUNCTION_NAME_EXIT;
   
7. }
   
8. 
   
9. void AppCallbackNotifier::frameCallback(CameraFrame* caFrame)
   
10. {
    
11.     ///Post the event to the event queue of AppCallbackNotifier
    
12.     TIUTILS::Message msg;
    
13.     CameraFrame *frame;
    
14. 
    
15.     LOG_FUNCTION_NAME;
    
16. 
    
17.     if ( NULL != caFrame )
    
18.         {
    
19. 
    
20.         frame = new CameraFrame(*caFrame);
    
21.         if ( NULL != frame )
    
22.             {
    
23.               msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME;
    
24.               msg.arg1 = frame;
    
25.               mFrameQ.put(&msg);
    
26.             }
    
27.         else
    
28.             {
    
29.             CAMHAL_LOGEA("Not enough resources to allocate CameraFrame");
    
30.             }
    
31. 
    
32.         }
    
33. 
    
34.     LOG_FUNCTION_NAME_EXIT;
    
35. }

这个回调函数只是将数据装载入mag这个消息结构体，比且把这个消息put到mFrameQ这个全局消息中心，app就是从这个消息中心把数据取走的
我们可以看一下在 AppCallbackNotifier初始化的时候就调用了initialize做一下初始设置

1. /**
   
2.   * NotificationHandler class
   
3.   */
   
4. 
   
5. ///Initialization function for AppCallbackNotifier
   
6. status_t AppCallbackNotifier::initialize()
   
7. {
   
8.     LOG_FUNCTION_NAME;
   
9. 
   
10.     mPreviewMemory = 0;
    
11. 
    
12.     mMeasurementEnabled = false;
    
13. 
    
14.     mNotifierState = NOTIFIER_STOPPED;
    
15. 
    
16.     ///Create the app notifier thread
    
17.     mNotificationThread = new NotificationThread(this);
    
18.     if(!mNotificationThread.get())
    
19.         {
    
20.         CAMHAL_LOGEA("Couldn't create Notification thread");
    
21.         return NO_MEMORY;
    
22.         }
    
23. 
    
24.     ///Start the display thread
    
25.     status_t ret = mNotificationThread->run("NotificationThread", PRIORITY_URGENT_DISPLAY);
    
26.     if(ret!=NO_ERROR)
    
27.         {
    
28.         CAMHAL_LOGEA("Couldn't run NotificationThread");
    
29.         mNotificationThread.clear();
    
30.         return ret;
    
31.         }
    
32. 
    
33.     mUseMetaDataBufferMode = true;
    
34.     mRawAvailable = false;
    
35. 
    
36.     mRecording = false;
    
37.     mPreviewing = false;
    
38. 
    
39.     LOG_FUNCTION_NAME_EXIT;
    
40. 
    
41.     return ret;
    
42. }

这个初始化的方法里面最重要就是开启了一个线程，用来监听HAL层发送来的一切消息，并在其中将消息或者数据告诉app，看看这个线程的具体实现

1. bool AppCallbackNotifier::notificationThread()
   
2. {
   
3.     bool shouldLive = true;
   
4.     status_t ret;
   
5. 
   
6.     LOG_FUNCTION_NAME;
   
7. 
   
8.     //CAMHAL_LOGDA("Notification Thread waiting for message");
   
9.     ret = TIUTILS::MessageQueue::waitForMsg(&mNotificationThread->msgQ(),
   
10.                                             &mEventQ,
    
11.                                             &mFrameQ,
    
12.                                             AppCallbackNotifier::NOTIFIER_TIMEOUT);
    
13. 
    
14.     //CAMHAL_LOGDA("Notification Thread received message");
    
15. 
    
16.     if (mNotificationThread->msgQ().hasMsg()) {
    
17.         ///Received a message from CameraHal, process it
    
18.         CAMHAL_LOGDA("Notification Thread received message from Camera HAL");
    
19.         shouldLive = processMessage();
    
20.         if(!shouldLive) {
    
21.           CAMHAL_LOGDA("Notification Thread exiting.");
    
22.           return shouldLive;
    
23.         }
    
24.     }
    
25. 
    
26.     if(mEventQ.hasMsg()) {
    
27.         ///Received an event from one of the event providers
    
28.         CAMHAL_LOGDA("Notification Thread received an event from event provider (CameraAdapter)");
    
29.         notifyEvent();
    
30.      }
    
31. 
    
32.     if(mFrameQ.hasMsg()) {
    
33.        ///Received a frame from one of the frame providers
    
34.        //CAMHAL_LOGDA("Notification Thread received a frame from frame provider (CameraAdapter)");
    
35.        notifyFrame();
    
36.     }
    
37. 
    
38.     LOG_FUNCTION_NAME_EXIT;
    
39.     return shouldLive;
    
40. }

这里等待到有消息时，我们直接分析我需要的，preview，如果检测到mFrameQ中有消息，则调用notifyFrame方法

1. void AppCallbackNotifier::notifyFrame()
   
2. {
   
3.     ///Receive and send the frame notifications to app
   
4.     TIUTILS::Message msg;
   
5.     CameraFrame *frame;
   
6.     MemoryHeapBase *heap;
   
7.     MemoryBase *buffer = NULL;
   
8.     sp<MemoryBase> memBase;
   
9.     void *buf = NULL;
   
10. 
    
11.     LOG_FUNCTION_NAME;
    
12. 
    
13.     {
    
14.         Mutex::Autolock lock(mLock);
    
15.         if(!mFrameQ.isEmpty()) {
    
16.             mFrameQ.get(&msg);
    
17.         } else {
    
18.             return;
    
19.         }
    
20.     }
    
21. 
    
22.     bool ret = true;
    
23. 
    
24.     frame = NULL;
    
25.     switch(msg.command)
    
26.         {
    
27.         case AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME:
    
28. 
    
29.                 frame = (CameraFrame *) msg.arg1;
    
30.                 if(!frame)
    
31.                     {
    
32.                     break;
    
33.                     }
    
34. 
    
35.                 if ( (CameraFrame::RAW_FRAME == frame->mFrameType )&&
    
36.                     ( NULL != mCameraHal ) &&
    
37.                     ( NULL != mDataCb) &&
    
38.                     ( NULL != mNotifyCb ) )
    
39.                     {
    
40. 
    
41.                     if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE) )
    
42.                         {
    
43. #ifdef COPY_IMAGE_BUFFER
    
44.                         copyAndSendPictureFrame(frame, CAMERA_MSG_RAW_IMAGE);
    
45. #else
    
46.                         //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
    
47. #endif
    
48.                         }
    
49.                     else {
    
50.                         if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE_NOTIFY) ) {
    
51.                             mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
    
52.                         }
    
53.                         mFrameProvider->returnFrame(frame->mBuffer,
    
54.                                                     (CameraFrame::FrameType) frame->mFrameType);
    
55.                     }
    
56. 
    
57.                     mRawAvailable = true;
    
58. 
    
59.                     }
    
60.                 else if ( (CameraFrame::IMAGE_FRAME == frame->mFrameType) &&
    
61.                           (NULL != mCameraHal) &&
    
62.                           (NULL != mDataCb) &&
    
63.                           (CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG & frame->mQuirks) )
    
64.                     {
    
65. 
    
66.                     int encode_quality = 100, tn_quality = 100;
    
67.                     int tn_width, tn_height;
    
68.                     unsigned int current_snapshot = 0;
    
69.                     Encoder_libjpeg::params *main_jpeg = NULL, *tn_jpeg = NULL;
    
70.                     void* exif_data = NULL;
    
71.                     const char *previewFormat = NULL;
    
72.                     camera_memory_t* raw_picture = mRequestMemory(-1, frame->mLength, 1, NULL);
    
73. 
    
74.                     if(raw_picture) {
    
75.                         buf = raw_picture->data;
    
76.                     }
    
77. 
    
78.                     CameraParameters parameters;
    
79.                     char *params = mCameraHal->getParameters();
    
80.                     const String8 strParams(params);
    
81.                     parameters.unflatten(strParams);
    
82. 
    
83.                     encode_quality = parameters.getInt(CameraParameters::KEY_JPEG_QUALITY);
    
84.                     if (encode_quality < 0 || encode_quality > 100) {
    
85.                         encode_quality = 100;
    
86.                     }
    
87. 
    
88.                     tn_quality = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
    
89.                     if (tn_quality < 0 || tn_quality > 100) {
    
90.                         tn_quality = 100;
    
91.                     }
    
92. 
    
93.                     if (CameraFrame::HAS_EXIF_DATA & frame->mQuirks) {
    
94.                         exif_data = frame->mCookie2;
    
95.                     }
    
96. 
    
97.                     main_jpeg = (Encoder_libjpeg::params*)
    
98.                                     malloc(sizeof(Encoder_libjpeg::params));
    
99. 
    
100.                     // Video snapshot with LDCNSF on adds a few bytes start offset
     
101.                     // and a few bytes on every line. They must be skipped.
     
102.                     int rightCrop = frame->mAlignment/2 - frame->mWidth;
     
103. 
     
104.                     CAMHAL_LOGDB("Video snapshot right crop = %d", rightCrop);
     
105.                     CAMHAL_LOGDB("Video snapshot offset = %d", frame->mOffset);
     
106. 
     
107.                     if (main_jpeg) {
     
108.                         main_jpeg->src = (uint8_t *)frame->mBuffer->mapped;
     
109.                         main_jpeg->src_size = frame->mLength;
     
110.                         main_jpeg->dst = (uint8_t*) buf;
     
111.                         main_jpeg->dst_size = frame->mLength;
     
112.                         main_jpeg->quality = encode_quality;
     
113.                         main_jpeg->in_width = frame->mAlignment/2; // use stride here
     
114.                         main_jpeg->in_height = frame->mHeight;
     
115.                         main_jpeg->out_width = frame->mAlignment/2;
     
116.                         main_jpeg->out_height = frame->mHeight;
     
117.                         main_jpeg->right_crop = rightCrop;
     
118.                         main_jpeg->start_offset = frame->mOffset;
     
119.                         if ( CameraFrame::FORMAT_YUV422I_UYVY & frame->mQuirks) {
     
120.                             main_jpeg->format = TICameraParameters::PIXEL_FORMAT_YUV422I_UYVY;
     
121.                         }
     
122.                         else { //if ( CameraFrame::FORMAT_YUV422I_YUYV & frame->mQuirks)
     
123.                             main_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV422I;
     
124.                         }
     
125.                     }
     
126. 
     
127.                     tn_width = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
     
128.                     tn_height = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
     
129.                     previewFormat = parameters.getPreviewFormat();
     
130. 
     
131.                     if ((tn_width > 0) && (tn_height > 0) && ( NULL != previewFormat )) {
     
132.                         tn_jpeg = (Encoder_libjpeg::params*)
     
133.                                       malloc(sizeof(Encoder_libjpeg::params));
     
134.                         // if malloc fails just keep going and encode main jpeg
     
135.                         if (!tn_jpeg) {
     
136.                             tn_jpeg = NULL;
     
137.                         }
     
138.                     }
     
139. 
     
140.                     if (tn_jpeg) {
     
141.                         int width, height;
     
142.                         parameters.getPreviewSize(&width,&height);
     
143.                         current_snapshot = (mPreviewBufCount + MAX_BUFFERS - 1) % MAX_BUFFERS;
     
144.                         tn_jpeg->src = (uint8_t *)mPreviewBuffers[current_snapshot].mapped;
     
145.                         tn_jpeg->src_size = mPreviewMemory->size / MAX_BUFFERS;
     
146.                         tn_jpeg->dst_size = calculateBufferSize(tn_width,
     
147.                                                                 tn_height,
     
148.                                                                 previewFormat);
     
149.                         tn_jpeg->dst = (uint8_t*) malloc(tn_jpeg->dst_size);
     
150.                         tn_jpeg->quality = tn_quality;
     
151.                         tn_jpeg->in_width = width;
     
152.                         tn_jpeg->in_height = height;
     
153.                         tn_jpeg->out_width = tn_width;
     
154.                         tn_jpeg->out_height = tn_height;
     
155.                         tn_jpeg->right_crop = 0;
     
156.                         tn_jpeg->start_offset = 0;
     
157.                         tn_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV420SP;;
     
158.                     }
     
159. 
     
160.                     sp<Encoder_libjpeg> encoder = new Encoder_libjpeg(main_jpeg,
     
161.                                                       tn_jpeg,
     
162.                                                       AppCallbackNotifierEncoderCallback,
     
163.                                                       (CameraFrame::FrameType)frame->mFrameType,
     
164.                                                       this,
     
165.                                                       raw_picture,
     
166.                                                       exif_data, frame->mBuffer);
     
167.                     gEncoderQueue.add(frame->mBuffer->mapped, encoder);
     
168.                     encoder->run();
     
169.                     encoder.clear();
     
170.                     if (params != NULL)
     
171.                       {
     
172.                         mCameraHal->putParameters(params);
     
173.                       }
     
174.                     }
     
175.                 else if ( ( CameraFrame::IMAGE_FRAME == frame->mFrameType ) &&
     
176.                              ( NULL != mCameraHal ) &&
     
177.                              ( NULL != mDataCb) )
     
178.                     {
     
179. 
     
180.                     // CTS, MTS requirements: Every 'takePicture()' call
     
181.                     // who registers a raw callback should receive one
     
182.                     // as well. This is not always the case with
     
183.                     // CameraAdapters though.
     
184.                     if (!mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE)) {
     
185.                         dummyRaw();
     
186.                     } else {
     
187.                         mRawAvailable = false;
     
188.                     }
     
189. 
     
190. #ifdef COPY_IMAGE_BUFFER
     
191.                     {
     
192.                         Mutex::Autolock lock(mBurstLock);
     
193. #if defined(OMAP_ENHANCEMENT)
     
194.                         if ( mBurst )
     
195.                         {
     
196.                             copyAndSendPictureFrame(frame, CAMERA_MSG_COMPRESSED_BURST_IMAGE);
     
197.                         }
     
198.                         else
     
199. #endif
     
200.                         {
     
201.                             copyAndSendPictureFrame(frame, CAMERA_MSG_COMPRESSED_IMAGE);
     
202.                         }
     
203.                     }
     
204. #else
     
205.                      //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
     
206. #endif
     
207.                     }
     
208.                 else if ( ( CameraFrame::VIDEO_FRAME_SYNC == frame->mFrameType ) &&
     
209.                              ( NULL != mCameraHal ) &&
     
210.                              ( NULL != mDataCb) &&
     
211.                              ( mCameraHal->msgTypeEnabled(CAMERA_MSG_VIDEO_FRAME) ) )
     
212.                     {
     
213.                     AutoMutex locker(mRecordingLock);
     
214.                     if(mRecording)
     
215.                         {
     
216.                         if(mUseMetaDataBufferMode)
     
217.                             {
     
218.                             camera_memory_t *videoMedatadaBufferMemory =
     
219.                                              mVideoMetadataBufferMemoryMap.valueFor(frame->mBuffer->opaque);
     
220.                             video_metadata_t *videoMetadataBuffer = (video_metadata_t *) videoMedatadaBufferMemory->data;
     
221. 
     
222.                             if( (NULL == videoMedatadaBufferMemory) || (NULL == videoMetadataBuffer) || (NULL == frame->mBuffer) )
     
223.                                 {
     
224.                                 CAMHAL_LOGEA("Error! One of the video buffers is NULL");
     
225.                                 break;
     
226.                                 }
     
227. 
     
228.                             if ( mUseVideoBuffers )
     
229.                               {
     
230.                                 CameraBuffer *vBuf = mVideoMap.valueFor(frame->mBuffer->opaque);
     
231.                                 GraphicBufferMapper &mapper = GraphicBufferMapper::get();
     
232.                                 Rect bounds;
     
233.                                 bounds.left = 0;
     
234.                                 bounds.top = 0;
     
235.                                 bounds.right = mVideoWidth;
     
236.                                 bounds.bottom = mVideoHeight;
     
237. 
     
238.                                 void *y_uv[2];
     
239.                                 mapper.lock((buffer_handle_t)vBuf, CAMHAL_GRALLOC_USAGE, bounds, y_uv);
     
240.                                 y_uv[1] = y_uv[0] + mVideoHeight*4096;
     
241. 
     
242.                                 structConvImage input = {frame->mWidth,
     
243.                                                           frame->mHeight,
     
244.                                                           4096,
     
245.                                                           IC_FORMAT_YCbCr420_lp,
     
246.                                                           (mmByte *)frame->mYuv[0],
     
247.                                                           (mmByte *)frame->mYuv[1],
     
248.                                                           frame->mOffset};
     
249. 
     
250.                                 structConvImage output = {mVideoWidth,
     
251.                                                           mVideoHeight,
     
252.                                                           4096,
     
253.                                                           IC_FORMAT_YCbCr420_lp,
     
254.                                                           (mmByte *)y_uv[0],
     
255.                                                           (mmByte *)y_uv[1],
     
256.                                                           0};
     
257. 
     
258.                                 VT_resizeFrame_Video_opt2_lp(&input, &output, NULL, 0);
     
259.                                 mapper.unlock((buffer_handle_t)vBuf->opaque);
     
260.                                 videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
     
261.                                 /* FIXME remove cast */
     
262.                                 videoMetadataBuffer->handle = (void *)vBuf->opaque;
     
263.                                 videoMetadataBuffer->offset = 0;
     
264.                               }
     
265.                             else
     
266.                               {
     
267.                                 videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
     
268.                                 videoMetadataBuffer->handle = camera_buffer_get_omx_ptr(frame->mBuffer);
     
269.                                 videoMetadataBuffer->offset = frame->mOffset;
     
270.                               }
     
271. 
     
272.                             CAMHAL_LOGVB("mDataCbTimestamp : frame->mBuffer=0x%x, videoMetadataBuffer=0x%x, videoMedatadaBufferMemory=0x%x",
     
273.                                             frame->mBuffer->opaque, videoMetadataBuffer, videoMedatadaBufferMemory);
     
274. 
     
275.                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME,
     
276.                                                 videoMedatadaBufferMemory, 0, mCallbackCookie);
     
277.                             }
     
278.                         else
     
279.                             {
     
280.                             //TODO: Need to revisit this, should ideally be mapping the TILER buffer using mRequestMemory
     
281.                             camera_memory_t* fakebuf = mRequestMemory(-1, sizeof(buffer_handle_t), 1, NULL);
     
282.                             if( (NULL == fakebuf) || ( NULL == fakebuf->data) || ( NULL == frame->mBuffer))
     
283.                                 {
     
284.                                 CAMHAL_LOGEA("Error! One of the video buffers is NULL");
     
285.                                 break;
     
286.                                 }
     
287. 
     
288.                             *reinterpret_cast<buffer_handle_t*>(fakebuf->data) = reinterpret_cast<buffer_handle_t>(frame->mBuffer->mapped);
     
289.                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME, fakebuf, 0, mCallbackCookie);
     
290.                             fakebuf->release(fakebuf);
     
291.                             }
     
292.                         }
     
293.                     }
     
294.                 else if(( CameraFrame::SNAPSHOT_FRAME == frame->mFrameType ) &&
     
295.                              ( NULL != mCameraHal ) &&
     
296.                              ( NULL != mDataCb) &&
     
297.                              ( NULL != mNotifyCb)) {
     
298.                     //When enabled, measurement data is sent instead of video data
     
299.                     if ( !mMeasurementEnabled ) {
     
300.                         copyAndSendPreviewFrame(frame, CAMERA_MSG_POSTVIEW_FRAME);
     
301.                     } else {
     
302.                         mFrameProvider->returnFrame(frame->mBuffer,
     
303.                                                     (CameraFrame::FrameType) frame->mFrameType);
     
304.                     }
     
305.                 }
     
306.                 else if ( ( CameraFrame::PREVIEW_FRAME_SYNC== frame->mFrameType ) &&
     
307.                             ( NULL != mCameraHal ) &&
     
308.                             ( NULL != mDataCb) &&
     
309.                             ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) ) {
     
310.                     //When enabled, measurement data is sent instead of video data
     
311.                     if ( !mMeasurementEnabled ) {
     
312.                         copyAndSendPreviewFrame(frame, CAMERA_MSG_PREVIEW_FRAME);
     
313.                     } else {
     
314.                          mFrameProvider->returnFrame(frame->mBuffer,
     
315.                                                      (CameraFrame::FrameType) frame->mFrameType);
     
316.                     }
     
317.                 }
     
318.                 else if ( ( CameraFrame::FRAME_DATA_SYNC == frame->mFrameType ) &&
     
319.                             ( NULL != mCameraHal ) &&
     
320.                             ( NULL != mDataCb) &&
     
321.                             ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) ) {
     
322.                     copyAndSendPreviewFrame(frame, CAMERA_MSG_PREVIEW_FRAME);
     
323.                 } else {
     
324.                     mFrameProvider->returnFrame(frame->mBuffer,
     
325.                                                 ( CameraFrame::FrameType ) frame->mFrameType);
     
326.                     CAMHAL_LOGDB("Frame type 0x%x is still unsupported!", frame->mFrameType);
     
327.                 }
     
328. 
     
329.                 break;
     
330. 
     
331.         default:
     
332. 
     
333.             break;
     
334. 
     
335.         };
     
336. 
     
337. exit:
     
338. 
     
339.     if ( NULL != frame )
     
340.         {
     
341.         delete frame;
     
342.         }
     
343. 
     
344.     LOG_FUNCTION_NAME_EXIT;
     
345. }

这里对不同的操作方式做了不同的处理，我们还是先通过preview过程作分析，如上面标注的那样处理，这里看看 copyAndSendPreviewFrame 的实现方法：

1. void AppCallbackNotifier::copyAndSendPreviewFrame(CameraFrame* frame, int32_t msgType)
   
2. {
   
3.     camera_memory_t* picture = NULL;
   
4.     CameraBuffer * dest = NULL;
   
5. 
   
6.     // scope for lock
   
7.     {
   
8.         Mutex::Autolock lock(mLock);
   
9. 
   
10.         if(mNotifierState != AppCallbackNotifier::NOTIFIER_STARTED) {
    
11.             goto exit;
    
12.         }
    
13. 
    
14.         if (!mPreviewMemory || !frame->mBuffer) {
    
15.             CAMHAL_LOGDA("Error! One of the buffer is NULL");
    
16.             goto exit;
    
17.         }
    
18. 
    
19.         dest = &mPreviewBuffers[mPreviewBufCount];
    
20. 
    
21.         CAMHAL_LOGVB("%d:copy2Dto1D(%p, %p, %d, %d, %d, %d, %d,%s)",
    
22.                      __LINE__,
    
23.                       dest,
    
24.                       frame->mBuffer,
    
25.                       mPreviewWidth,
    
26.                       mPreviewHeight,
    
27.                       mPreviewStride,
    
28.                       2,
    
29.                       frame->mLength,
    
30.                       mPreviewPixelFormat);
    
31. 
    
32.         /* FIXME map dest */
    
33.         if ( NULL != dest && dest->mapped != NULL ) {
    
34.             // data sync frames don't need conversion
    
35.             if (CameraFrame::FRAME_DATA_SYNC == frame->mFrameType) {
    
36.                 if ( (mPreviewMemory->size / MAX_BUFFERS) >= frame->mLength ) {
    
37.                     memcpy(dest->mapped, (void*) frame->mBuffer->mapped, frame->mLength);
    
38.                 } else {
    
39.                     memset(dest->mapped, 0, (mPreviewMemory->size / MAX_BUFFERS));
    
40.                 }
    
41.             } else {
    
42.               if ((NULL == frame->mYuv[0]) || (NULL == frame->mYuv[1])){
    
43.                 CAMHAL_LOGEA("Error! One of the YUV Pointer is NULL");
    
44.                 goto exit;
    
45.               }
    
46.               else{
    
47.                 copy2Dto1D(dest->mapped,
    
48.                            frame->mYuv,
    
49.                            mPreviewWidth,
    
50.                            mPreviewHeight,
    
51.                            mPreviewStride,
    
52.                            frame->mOffset,
    
53.                            2,
    
54.                            frame->mLength,
    
55.                            mPreviewPixelFormat);
    
56.               }
    
57.             }
    
58.         }
    
59.     }
    
60. 
    
61.  exit:
    
62.     mFrameProvider->returnFrame(frame->mBuffer, (CameraFrame::FrameType) frame->mFrameType);
    
63. 
    
64.     if((mNotifierState == AppCallbackNotifier::NOTIFIER_STARTED) &&
    
65.        mCameraHal->msgTypeEnabled(msgType) &&
    
66.        (dest != NULL) && (dest->mapped != NULL)) {
    
67.         AutoMutex locker(mLock);
    
68.         if ( mPreviewMemory )
    
69.             mDataCb(msgType, mPreviewMemory, mPreviewBufCount, NULL, mCallbackCookie);
    
70.     }
    
71. 
    
72.     // increment for next buffer
    
73.     mPreviewBufCount = (mPreviewBufCount + 1) % AppCallbackNotifier::MAX_BUFFERS;
    
74. }

具体中间的实现过程这里就先不做具体分析，我们只看最后这一个标注的方法mDataCb，他的定义是这样的
camera_data_callback   mDataCb;
这个方法的实现很关键，其实他是在cameraservice中实现，过程如下：
1.cameraservice中调用mHardware->setCallbacks(notifyCallback,dataCallback, dataCallbackTimestamp, (void *)cameraId);
2.camerahardwareinterface中调用mDevice->ops->set_callbacks(mDevice,__notify_cb,__data_cb, __data_cb_timestamp, __get_memory, this);
3.camerahal_module中调用gCameraHals[ti_dev->cameraid]->setCallbacks(notify_cb, data_cb, data_cb_timestamp, get_memory, user);
4.camerahal中调用mAppCallbackNotifier->setCallbacks(this,notify_cb, data_cb, data_cb_timestamp, get_memory, user);
5.这里就到了appcallbacknotifier中，我们就看看这个setcallbacks的实现吧

1. void AppCallbackNotifier::setCallbacks(CameraHal* cameraHal,
   
2.                                         camera_notify_callback notify_cb,
   
3.                                         camera_data_callback data_cb,
   
4.                                         camera_data_timestamp_callback data_cb_timestamp,
   
5.                                         camera_request_memory get_memory,
   
6.                                         void *user)
   
7. {
   
8.     Mutex::Autolock lock(mLock);
   
9. 
   
10.     LOG_FUNCTION_NAME;
    
11. 
    
12.     mCameraHal = cameraHal;
    
13.     mNotifyCb = notify_cb;
    
14.     mDataCb = data_cb;
    
15.     mDataCbTimestamp = data_cb_timestamp;
    
16.     mRequestMemory = get_memory;
    
17.     mCallbackCookie = user;
    
18. 
    
19.     LOG_FUNCTION_NAME_EXIT;
    
20. }

这里可以很清楚的看到mDataCb就是指向cameraservice中定义的回调函数，也就是通过这种机制，最终底层获取的数据现在已经传递到cameraservice层了
不过这里还是要很注意一点，我上面我说的 mDataCb就是指向cameraservice中定义的回调函数也是不准确的说法，准确的说法应该是 mDataCb的实现方法最红会调用到cameraservice中定义的回调函数，
这里还是花点时间说明一下这个回调过程：
mDataCb其实真正知道的是camerahardwareinterface中定义的__data_cb实现，这是由以下调用决定的
mDevice->ops->set_callbacks(mDevice,
                                   __notify_cb,
                                   __data_cb,
                                   __data_cb_timestamp,
                                   __get_memory,
                                   this);
下面来看看的 __data_cb 定义

1. static void __data_cb(int32_t msg_type,
   
2.                           const camera_memory_t *data, unsigned int index,
   
3.                           camera_frame_metadata_t *metadata,
   
4.                           void *user)
   
5.     {
   
6.         LOGV("%s", __FUNCTION__);
   
7.         CameraHardwareInterface *__this =
   
8.                 static_cast<CameraHardwareInterface *>(user);
   
9.         sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
   
10.         if (index >= mem->mNumBufs) {
    
11.             LOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
    
12.                  index, mem->mNumBufs);
    
13.             return;
    
14.         }
    
15.         __this->mDataCb(msg_type, mem->mBuffers[index], metadata, __this->mCbUser);
    
16.     }

而这里这个mDataCb又是哪里来的

1. /** Set the notification and data callbacks */
   
2.     void setCallbacks(notify_callback notify_cb,
   
3.                       data_callback data_cb,
   
4.                       data_callback_timestamp data_cb_timestamp,
   
5.                       void* user)
   
6.     {
   
7.         mNotifyCb = notify_cb;
   
8.         mDataCb = data_cb;
   
9.         mDataCbTimestamp = data_cb_timestamp;
   
10.         mCbUser = user;
    
11. 
    
12.         LOGV("%s(%s)", __FUNCTION__, mName.string());
    
13. 
    
14.         if (mDevice->ops->set_callbacks) {
    
15.             mDevice->ops->set_callbacks(mDevice,
    
16.                                    __notify_cb,
    
17.                                    __data_cb,
    
18.                                    __data_cb_timestamp,
    
19.                                    __get_memory,
    
20.                                    this);
    
21.         }
    
22.     }

找里大家清楚的看到了mDataCb就指向cameraservice中定义的datacallback方法，这个过程只是稍微绕了下圈

这里还是继续分析吧，看看数据到底是怎样送到app的，下面看看cameraservice中的这个datacallback方法的定义

1. void CameraService::Client::dataCallback(int32_t msgType,
   
2.         const sp<IMemory>& dataPtr, camera_frame_metadata_t *metadata, void* user) {
   
3.     LOG2("dataCallback(%d)", msgType);
   
4. 
   
5.     sp<Client> client = getClientFromCookie(user);
   
6.     if (client == 0) return;
   
7.     if (!client->lockIfMessageWanted(msgType)) return;
   
8. 
   
9.     if (dataPtr == 0 && metadata == NULL) {
   
10.         LOGE("Null data returned in data callback");
    
11.         client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
    
12.         return;
    
13.     }
    
14. 
    
15.     switch (msgType & ~CAMERA_MSG_PREVIEW_METADATA) {
    
16.         case CAMERA_MSG_PREVIEW_FRAME:
    
17.             client->handlePreviewData(msgType, dataPtr, metadata);
    
18.             break;
    
19.         case CAMERA_MSG_POSTVIEW_FRAME:
    
20.             client->handlePostview(dataPtr);
    
21.             break;
    
22.         case CAMERA_MSG_RAW_IMAGE:
    
23.             client->handleRawPicture(dataPtr);
    
24.             break;
    
25.         case CAMERA_MSG_COMPRESSED_IMAGE:
    
26.             client->handleCompressedPicture(dataPtr);
    
27.             break;
    
28. #ifdef OMAP_ENHANCEMENT
    
29.         case CAMERA_MSG_COMPRESSED_BURST_IMAGE:
    
30.             client->handleCompressedBurstPicture(dataPtr);
    
31.             break;
    
32. #endif
    
33.         default:
    
34.             client->handleGenericData(msgType, dataPtr, metadata);
    
35.             break;
    
36.     }
    
37. }

preview数据是通过上面的 client - > handlePreviewData ( msgType ,  dataPtr ,  metadata ) ; 方法继续往上走的，通过这种方式，数据由cameras层---->cameraclient层
接着看看cameraclent的实现

1. // callback from camera service when frame or image is ready
   
2. void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr,
   
3.                           camera_frame_metadata_t *metadata)
   
4. {
   
5.     sp<CameraListener> listener;
   
6.     {
   
7.         Mutex::Autolock _l(mLock);
   
8.         listener = mListener;
   
9.     }
   
10.     if (listener != NULL) {
    
11.         listener->postData(msgType, dataPtr, metadata);
    
12.     }
    
13. }

这里的listener到底是什么，还记得初始化的时候，在jni里面有设置listenerm吗？我们还是从新再看一下吧：frameworks/base/core/jni/android_hardware_Camera.cpp

1. // connect to camera service
   
2. static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,
   
3.     jobject weak_this, jint cameraId)
   
4. {
   
5.     sp<Camera> camera = Camera::connect(cameraId);
   
6. 
   
7.     if (camera == NULL) {
   
8.         jniThrowRuntimeException(env, "Fail to connect to camera service");
   
9.         return;
   
10.     }
    
11. 
    
12.     // make sure camera hardware is alive
    
13.     if (camera->getStatus() != NO_ERROR) {
    
14.         jniThrowRuntimeException(env, "Camera initialization failed");
    
15.         return;
    
16.     }
    
17. 
    
18.     jclass clazz = env->GetObjectClass(thiz);
    
19.     if (clazz == NULL) {
    
20.         jniThrowRuntimeException(env, "Can't find android/hardware/Camera");
    
21.         return;
    
22.     }
    
23. 
    
24.     // We use a weak reference so the Camera object can be garbage collected.
    
25.     // The reference is only used as a proxy for callbacks.
    
26.     sp<JNICameraContext> context = new JNICameraContext(env, weak_this, clazz, camera);
    
27.     context->incStrong(thiz);
    
28.     camera->setListener(context);
    
29. 
    
30.     // save context in opaque field
    
31.     env->SetIntField(thiz, fields.context, (int)context.get());
    
32. }

由上面可以看出 JNICameraContext 是个监听类，同时set这个监听类，这个类的定义在： frameworks/base/core/jni/android_hardware_Camera.cpp

1. // provides persistent context for calls from native code to Java
   
2. class JNICameraContext: public CameraListener
   
3. {
   
4. public:
   
5.     JNICameraContext(JNIEnv* env, jobject weak_this, jclass clazz, const sp<Camera>& camera);
   
6.     ~JNICameraContext() { release(); }
   
7.     virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
   
8.     virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr,
   
9.                           camera_frame_metadata_t *metadata);
   
10.     virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
    
11.     void postMetadata(JNIEnv *env, int32_t msgType, camera_frame_metadata_t *metadata);
    
12.     void addCallbackBuffer(JNIEnv *env, jbyteArray cbb, int msgType);
    
13.     void setCallbackMode(JNIEnv *env, bool installed, bool manualMode);
    
14.     sp<Camera> getCamera() { Mutex::Autolock _l(mLock); return mCamera; }
    
15.     bool isRawImageCallbackBufferAvailable() const;
    
16.     void release();
    
17. 
    
18. private:
    
19.     void copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType);
    
20.     void clearCallbackBuffers_l(JNIEnv *env, Vector<jbyteArray> *buffers);
    
21.     void clearCallbackBuffers_l(JNIEnv *env);
    
22.     jbyteArray getCallbackBuffer(JNIEnv *env, Vector<jbyteArray> *buffers, size_t bufferSize);
    
23. 
    
24.     jobject mCameraJObjectWeak; // weak reference to java object
    
25.     jclass mCameraJClass; // strong reference to java class
    
26.     sp<Camera> mCamera; // strong reference to native object
    
27.     jclass mFaceClass; // strong reference to Face class
    
28.     jclass mRectClass; // strong reference to Rect class
    
29.     Mutex mLock;
    
30. 
    
31.     /*
    
32.      * Global reference application-managed raw image buffer queue.
    
33.      *
    
34.      * Manual-only mode is supported for raw image callbacks, which is
    
35.      * set whenever method addCallbackBuffer() with msgType =
    
36.      * CAMERA_MSG_RAW_IMAGE is called; otherwise, null is returned
    
37.      * with raw image callbacks.
    
38.      */
    
39.     Vector<jbyteArray> mRawImageCallbackBuffers;
    
40. 
    
41.     /*
    
42.      * Application-managed preview buffer queue and the flags
    
43.      * associated with the usage of the preview buffer callback.
    
44.      */
    
45.     Vector<jbyteArray> mCallbackBuffers; // Global reference application managed byte[]
    
46.     bool mManualBufferMode; // Whether to use application managed buffers.
    
47.     bool mManualCameraCallbackSet; // Whether the callback has been set, used to
    
48.                                          // reduce unnecessary calls to set the callback.
    
49. };

标注部分是我们在上面用到的postData，我们看一看postData的实现过程：

1. void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr,
   
2.                                 camera_frame_metadata_t *metadata)
   
3. {
   
4.     // VM pointer will be NULL if object is released
   
5.     Mutex::Autolock _l(mLock);
   
6.     JNIEnv *env = AndroidRuntime::getJNIEnv();
   
7.     if (mCameraJObjectWeak == NULL) {
   
8.         LOGW("callback on dead camera object");
   
9.         return;
   
10.     }
    
11. 
    
12.     int32_t dataMsgType = msgType & ~CAMERA_MSG_PREVIEW_METADATA;
    
13. 
    
14.     // return data based on callback type
    
15.     switch (dataMsgType) {
    
16.         case CAMERA_MSG_VIDEO_FRAME:
    
17.             // should never happen
    
18.             break;
    
19. 
    
20.         // For backward-compatibility purpose, if there is no callback
    
21.         // buffer for raw image, the callback returns null.
    
22.         case CAMERA_MSG_RAW_IMAGE:
    
23.             LOGV("rawCallback");
    
24.             if (mRawImageCallbackBuffers.isEmpty()) {
    
25.                 env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
    
26.                         mCameraJObjectWeak, dataMsgType, 0, 0, NULL);
    
27.             } else {
    
28.                 copyAndPost(env, dataPtr, dataMsgType);
    
29.             }
    
30.             break;
    
31. 
    
32.         // There is no data.
    
33.         case 0:
    
34.             break;
    
35. 
    
36.         default:
    
37.             LOGV("dataCallback(%d, %p)", dataMsgType, dataPtr.get());
    
38.             copyAndPost(env, dataPtr, dataMsgType);
    
39.             break;
    
40.     }
    
41. 
    
42.     // post frame metadata to Java
    
43.     if (metadata && (msgType & CAMERA_MSG_PREVIEW_METADATA)) {
    
44.         postMetadata(env, CAMERA_MSG_PREVIEW_METADATA, metadata);
    
45.     }
    
46. }

我们接着看看这个 copyAndPost方法：

1. void JNICameraContext::copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType)
   
2. {
   
3.     jbyteArray obj = NULL;
   
4. 
   
5.     // allocate Java byte array and copy data
   
6.     if (dataPtr != NULL) {
   
7.         ssize_t offset;
   
8.         size_t size;
   
9.         sp<IMemoryHeap> heap = dataPtr->getMemory(&offset, &size);
   
10.         LOGV("copyAndPost: off=%ld, size=%d", offset, size);
    
11.         uint8_t *heapBase = (uint8_t*)heap->base();
    
12. 
    
13.         if (heapBase != NULL) {
    
14.             const jbyte* data = reinterpret_cast<const jbyte*>(heapBase + offset);
    
15. 
    
16.             if (msgType == CAMERA_MSG_RAW_IMAGE) {
    
17.                 obj = getCallbackBuffer(env, &mRawImageCallbackBuffers, size);
    
18.             } else if (msgType == CAMERA_MSG_PREVIEW_FRAME && mManualBufferMode) {
    
19.                 obj = getCallbackBuffer(env, &mCallbackBuffers, size);
    
20. 
    
21.                 if (mCallbackBuffers.isEmpty()) {
    
22.                     LOGV("Out of buffers, clearing callback!");
    
23.                     mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
    
24.                     mManualCameraCallbackSet = false;
    
25. 
    
26.                     if (obj == NULL) {
    
27.                         return;
    
28.                     }
    
29.                 }
    
30.             } else {
    
31.                 LOGV("Allocating callback buffer");
    
32.                 obj = env->NewByteArray(size);
    
33.             }
    
34. 
    
35.             if (obj == NULL) {
    
36.                 LOGE("Couldn't allocate byte array for JPEG data");
    
37.                 env->ExceptionClear();
    
38.             } else {
    
39.                 env->SetByteArrayRegion(obj, 0, size, data);
    
40.             }
    
41.         } else {
    
42.             LOGE("image heap is NULL");
    
43.         }
    
44.     }
    
45. 
    
46.     // post image data to Java
    
47.     env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
    
48.             mCameraJObjectWeak, msgType, 0, 0, obj);
    
49.     if (obj) {
    
50.         env->DeleteLocalRef(obj);
    
51.     }
    
52. }

以上先建立一个byte数组obj，将data缓存数据存储进obj数组，CallStaticVoidMethod是C调用java函数，最后执行实在Camera.java(框架）的postEventFromNative（）
从这里开始，回调函数进入到camera framework层
frameworks/base/core/java/android/hardware/Camera.java

1. private static void postEventFromNative(Object camera_ref,
   
2.                                             int what, int arg1, int arg2, Object obj)
   
3.     {
   
4.         Camera c = (Camera)((WeakReference)camera_ref).get();
   
5.         if (c == null)
   
6.             return;
   
7. 
   
8.         if (c.mEventHandler != null) {
   
9.             Message m = c.mEventHandler.obtainMessage(what, arg1, arg2, obj);
   
10.             c.mEventHandler.sendMessage(m);
    
11.         }
    
12.     }

sendMessage之后由handle进行处理，定义同样在framework层

1. private class EventHandler extends Handler
   
2.     {
   
3.         private Camera mCamera;
   
4. 
   
5.         public EventHandler(Camera c, Looper looper) {
   
6.             super(looper);
   
7.             mCamera = c;
   
8.         }
   
9. 
   
10.         @Override
    
11.         public void handleMessage(Message msg) {
    
12.             switch(msg.what) {
    
13.             case CAMERA_MSG_SHUTTER:
    
14.                 if (mShutterCallback != null) {
    
15.                     mShutterCallback.onShutter();
    
16.                 }
    
17.                 return;
    
18. 
    
19.             case CAMERA_MSG_RAW_IMAGE:
    
20.                 if (mRawImageCallback != null) {
    
21.                     mRawImageCallback.onPictureTaken((byte[])msg.obj, mCamera);
    
22.                 }
    
23.                 return;
    
24. 
    
25.             case CAMERA_MSG_COMPRESSED_IMAGE:
    
26.                 if (mJpegCallback != null) {
    
27.                     mJpegCallback.onPictureTaken((byte[])msg.obj, mCamera);
    
28.                 }
    
29.                 return;
    
30. 
    
31.             case CAMERA_MSG_PREVIEW_FRAME:
    
32.                 if (mPreviewCallback != null) {
    
33.                     PreviewCallback cb = mPreviewCallback;
    
34.                     if (mOneShot) {
    
35.                         // Clear the callback variable before the callback
    
36.                         // in case the app calls setPreviewCallback from
    
37.                         // the callback function
    
38.                         mPreviewCallback = null;
    
39.                     } else if (!mWithBuffer) {
    
40.                         // We're faking the camera preview mode to prevent
    
41.                         // the app from being flooded with preview frames.
    
42.                         // Set to oneshot mode again.
    
43.                         setHasPreviewCallback(true, false);
    
44.                     }
    
45.                     cb.onPreviewFrame((byte[])msg.obj, mCamera);
    
46.                 }
    
47.                 return;
    
48. 
    
49.             case CAMERA_MSG_POSTVIEW_FRAME:
    
50.                 if (mPostviewCallback != null) {
    
51.                     mPostviewCallback.onPictureTaken((byte[])msg.obj, mCamera);
    
52.                 }
    
53.                 return;
    
54. 
    
55.             case CAMERA_MSG_FOCUS:
    
56.                 if (mAutoFocusCallback != null) {
    
57.                     mAutoFocusCallback.onAutoFocus(msg.arg1 == 0 ? false : true, mCamera);
    
58.                 }
    
59.                 return;
    
60. 
    
61.             case CAMERA_MSG_ZOOM:
    
62.                 if (mZoomListener != null) {
    
63.                     mZoomListener.onZoomChange(msg.arg1, msg.arg2 != 0, mCamera);
    
64.                 }
    
65.                 return;
    
66. 
    
67.             case CAMERA_MSG_PREVIEW_METADATA:
    
68.                 if (mFaceListener != null) {
    
69.                     mFaceListener.onFaceDetection((Face[])msg.obj, mCamera);
    
70.                 }
    
71.                 return;
    
72. 
    
73.             case CAMERA_MSG_ERROR :
    
74.                 Log.e(TAG, "Error " + msg.arg1);
    
75.                 if (mErrorCallback != null) {
    
76.                     mErrorCallback.onError(msg.arg1, mCamera);
    
77.                 }
    
78.                 return;
    
79. 
    
80.             default:
    
81.                 Log.e(TAG, "Unknown message type " + msg.what);
    
82.                 return;
    
83.             }
    
84.         }
    
85.     }

上面可以看出，这里处理了所有的回调，快门回调mShutterCallback.onShutter()，RawImageCallback.onPictureTaken（）拍照数据回调，自动对焦回调等。。
默认是没有previewcallback这个回调的， 除非你的app设置了setPreviewCallback，可以看出preview的数据还是可以向上层回调，只是系统默认不回调，这里再说深一些：
由上面绿色标注的地方可以看出，我们需要做以下事情，检查 PreviewCallback  这个在framework中定义的接口有没有设置了setPreviewCallback，设置则调用，这里接口中
的 onPreviewFrame 方法需要开发者自己实现，这里默认是没有实现的，需要特殊使用的要自己添加，这里是自己的理解，看一下 PreviewCallback  接口的定义： frameworks/base/core/java/android/hardware/Camera.java

1. /**
   
2.      * Callback interface used to deliver copies of preview frames as
   
3.      * they are displayed.
   
4.      *
   
5.      * @see #setPreviewCallback(Camera.PreviewCallback)
   
6.      * @see #setOneShotPreviewCallback(Camera.PreviewCallback)
   
7.      * @see #setPreviewCallbackWithBuffer(Camera.PreviewCallback)
   
8.      * @see #startPreview()
   
9.      */
   
10.     public interface PreviewCallback
    
11.     {
    
12.         /**
    
13.          * Called as preview frames are displayed. This callback is invoked
    
14.          * on the event thread {@link #open(int)} was called from.
    
15.          *
    
16.          * @param data the contents of the preview frame in the format defined
    
17.          * by {@link android.graphics.ImageFormat}, which can be queried
    
18.          * with {@link android.hardware.Camera.Parameters#getPreviewFormat()}.
    
19.          * If {@link android.hardware.Camera.Parameters#setPreviewFormat(int)}
    
20.          * is never called, the default will be the YCbCr_420_SP
    
21.          * (NV21) format.
    
22.          * @param camera the Camera service object.
    
23.          */
    
24.         void onPreviewFrame(byte[] data, Camera camera);
    
25.     };

另数据采集区与显示区两个缓存区buffer preview数据的投递，以完成preview实时显示是在HAL层完成的 。

到这里为止，整个过程大致走了一遍，中间必定有很多不多，这也只是自己的学习记录，难免有自己错误的见解，待修正

待续。。。。。