Android Camera CameraHal.cpp 分析 参考：http://blog.chinaunix.net/uid-26765074-id-3582204.html
作为上层和底层的中转站，hal层在android中起到的作用不言而喻，针对camera的研究已经有一段时间了，这里自己还是决定静下心来好好的分析一下CameraHal.cpp这里的代码，
对自己更好的理解hal与上层和底层的交互作用不可小觑，特别对理解hal与kernel driver的交互过程作用很大
不多说废话了，开始今天的主题

我们首先从CameraHal的初始化，那么他是从哪里开始化的呢？这里之前的文章中已经有过，只是没有重点介绍，这里还是说一下吧
是在camera最初open的时候会调用到camerahal_module.cpp中的以下方法进行初始化的

1. /*******************************************************************
   
2. *implementation of camera_module functions
   
3. *******************************************************************/
   
4. 
   
5. /*open device handletoone of the cameras
   
6. *
   
7. *assume camera service will keep singleton ofeachcamera
   
8. *so thisfunctionwill always only be called once per camera instance
   
9. */
   
10. 
    
11. intcamera_device_open(consthw_module_t*module,constchar*name,
    
12. hw_device_t**device)
    
13. {
    
14. intrv=0;
    
15. intnum_cameras=0;
    
16. intcameraid;
    
17. ti_camera_device_t*camera_device=NULL;
    
18. camera_device_ops_t*camera_ops=NULL;
    
19. android::CameraHal*camera=NULL;
    
20. android::CameraProperties::Properties*properties=NULL;
    
21. 
    
22. android::Mutex::Autolock lock(gCameraHalDeviceLock);
    
23. 
    
24. LOGI("camera_device open");
    
25. 
    
26. if(name!=NULL){
    
27. cameraid=atoi(name);
    
28. num_cameras=gCameraProperties.camerasSupported();
    
29. 
    
30. if(cameraid>num_cameras)
    
31. {
    
32. LOGE("camera service provided cameraid out of bounds, "
    
33. "cameraid = %d, num supported = %d",
    
34. cameraid,num_cameras);
    
35. rv=-EINVAL;
    
36. goto fail;
    
37. }
    
38. 
    
39. if(gCamerasOpen>=MAX_SIMUL_CAMERAS_SUPPORTED)
    
40. {
    
41. LOGE("maximum number of cameras already open");
    
42. rv=-ENOMEM;
    
43. goto fail;
    
44. }
    
45. 
    
46. camera_device=(ti_camera_device_t*)malloc(sizeof(*camera_device));
    
47. if(!camera_device)
    
48. {
    
49. LOGE("camera_device allocation fail");
    
50. rv=-ENOMEM;
    
51. goto fail;
    
52. }
    
53. 
    
54. camera_ops=(camera_device_ops_t*)malloc(sizeof(*camera_ops));
    
55. if(!camera_ops)
    
56. {
    
57. LOGE("camera_ops allocation fail");
    
58. rv=-ENOMEM;
    
59. goto fail;
    
60. }
    
61. 
    
62. memset(camera_device,0,sizeof(*camera_device));
    
63. memset(camera_ops,0,sizeof(*camera_ops));
    
64. 
    
65. camera_device->base.common.tag=HARDWARE_DEVICE_TAG;
    
66. camera_device->base.common.version=0;
    
67. camera_device->base.common.module=(hw_module_t*)(module);
    
68. camera_device->base.common.close=camera_device_close;
    
69. camera_device->base.ops=camera_ops;
    
70. 
    
71. camera_ops->set_preview_window=camera_set_preview_window;
    
72. camera_ops->set_callbacks=camera_set_callbacks;
    
73. camera_ops->enable_msg_type=camera_enable_msg_type;
    
74. camera_ops->disable_msg_type=camera_disable_msg_type;
    
75. camera_ops->msg_type_enabled=camera_msg_type_enabled;
    
76. camera_ops->start_preview=camera_start_preview;
    
77. camera_ops->stop_preview=camera_stop_preview;
    
78. camera_ops->preview_enabled=camera_preview_enabled;
    
79. camera_ops->store_meta_data_in_buffers=camera_store_meta_data_in_buffers;
    
80. camera_ops->start_recording=camera_start_recording;
    
81. camera_ops->stop_recording=camera_stop_recording;
    
82. camera_ops->recording_enabled=camera_recording_enabled;
    
83. camera_ops->release_recording_frame=camera_release_recording_frame;
    
84. camera_ops->auto_focus=camera_auto_focus;
    
85. camera_ops->cancel_auto_focus=camera_cancel_auto_focus;
    
86. camera_ops->take_picture=camera_take_picture;
    
87. camera_ops->cancel_picture=camera_cancel_picture;
    
88. camera_ops->set_parameters=camera_set_parameters;
    
89. camera_ops->get_parameters=camera_get_parameters;
    
90. camera_ops->put_parameters=camera_put_parameters;
    
91. camera_ops->send_command=camera_send_command;
    
92. camera_ops->release=camera_release;
    
93. camera_ops->dump=camera_dump;
    
94. 
    
95. *device=&camera_device->base.common;
    
96. 
    
97. //--------TI specific stuff--------
    
98. 
    
99. camera_device->cameraid=cameraid;
    
100. 
     
101. if(gCameraProperties.getProperties(cameraid,&properties)<0)
     
102. {
     
103. LOGE("Couldn't get camera properties");
     
104. rv=-ENOMEM;
     
105. goto fail;
     
106. }
     
107. ****************重点就在这里了****************
     
108. camera=new android::CameraHal(cameraid);
     
109. 
     
110. if(!camera)
     
111. {
     
112. LOGE("Couldn't create instance of CameraHal class");
     
113. rv=-ENOMEM;
     
114. goto fail;
     
115. }
     
116. 
     
117. if(properties&&(camera->initialize(properties)!=android::NO_ERROR))
     
118. {
     
119. LOGE("Couldn't initialize camera instance");
     
120. rv=-ENODEV;
     
121. goto fail;
     
122. }
     
123. 
     
124. gCameraHals[cameraid]=camera;
     
125. gCamerasOpen++;
     
126. 
     
127. }
     
128. 
     
129. return rv;
     
130. 
     
131. fail:
     
132. if(camera_device){
     
133. free(camera_device);
     
134. camera_device=NULL;
     
135. }
     
136. if(camera_ops){
     
137. free(camera_ops);
     
138. camera_ops=NULL;
     
139. }
     
140. if(camera){
     
141. delete camera;
     
142. camera=NULL;
     
143. }
     
144. *device=NULL;
     
145. return rv;
     
146. }

上面横线中间的部分就是camerahal的初始化了，首先new camerahal，并且调用initialize方法，最后将实例化好的camerahal保存到gCameraHals这个数组中， 之后会通过这个数组找到我们实例化好的camerahal，实现我们对hal层接口的使用
现在我们就开始看看camerahal的initialize方法的实现

1. /**
   
2. @brief Initialize the Camera HAL
   
3. 
   
4. Creates CameraAdapter,AppCallbackNotifier,DisplayAdapterandMemoryManager
   
5. 
   
6. @param None
   
7. @return NO_ERROR-Onsuccess
   
8. NO_MEMORY-Onfailuretoallocate memoryforany of the objects
   
9. @remarks Camera Hal internalfunction
   
10. 
    
11. */
    
12. 
    
13. status_t CameraHal::initialize(CameraProperties::Properties*properties)
    
14. {
    
15. LOG_FUNCTION_NAME;
    
16. 
    
17. intsensor_index=0;
    
18. constchar*sensor_name=NULL;
    
19. 
    
20. ///Initialize the event mask usedforregistering an event providerforAppCallbackNotifier
    
21. ///Currently,registering all events astobe coming from CameraAdapter
    
22. int32_t eventMask=CameraHalEvent::ALL_EVENTS;
    
23. 
    
24. //Getmy 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 printifDEBUG macroisdefined
    
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);
    

1.这里很重要*******************************************************************************
这里做一个判断决定我们是使用V4LCameraAdapter还是OMXCameraAdapter
接下来将要重点学习OMX机制，这篇文章我们假设走else分支

1. if(strcmp(sensor_name,V4L_CAMERA_NAME_USB)==0){
   
2. #ifdef V4L_CAMERA_ADAPTER
   
3. mCameraAdapter=V4LCameraAdapter_Factory(sensor_index);
   
4. #endif
   
5. }
   
6. else{
   
7. #ifdef OMX_CAMERA_ADAPTER
   
8. mCameraAdapter=OMXCameraAdapter_Factory(sensor_index);
   
9. #endif
   
10. }
    
11. 
    
12. if((NULL==mCameraAdapter)||(mCameraAdapter->initialize(properties)!=NO_ERROR))
    
13. {
    
14. CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
    
15. mCameraAdapter=NULL;
    
16. goto fail_loop;
    
17. }
    
18. 
    
19. mCameraAdapter->incStrong(mCameraAdapter);
    
20. mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers,(void*)this);
    
21. mCameraAdapter->registerEndCaptureCallback(endImageCapture,(void*)this);
    

2.这里很重要*****************************************************************************
这里实例化一个AppCallbackNotifier，并且调用initialize方法进行初始化

1. if(!mAppCallbackNotifier.get())
   
2. {
   
3. ///Create the callback notifier
   
4. mAppCallbackNotifier=new AppCallbackNotifier();
   
5. if((NULL==mAppCallbackNotifier.get())||(mAppCallbackNotifier->initialize()!=NO_ERROR))
   
6. {
   
7. CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
   
8. goto fail_loop;
   
9. }
   
10. }
    

3.这里很重要*****************************************************************************
这里实例化一个MemoryManager，并且调用initialize方法进行初始化，以及其他一些set 或者初始化

1. if(!mMemoryManager.get())
   
2. {
   
3. ///Create Memory Manager
   
4. mMemoryManager=new MemoryManager();
   
5. if((NULL==mMemoryManager.get())||(mMemoryManager->initialize()!=NO_ERROR))
   
6. {
   
7. CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
   
8. goto fail_loop;
   
9. }
   
10. }
    
11. 
    
12. ///Setup theclassdependencies...
    
13. 
    
14. ///AppCallbackNotifier hastoknow wheretogetthe Camera framesandthe events like auto focus lock etc from.
    
15. ///CameraAdapteristhe one which provides those events
    
16. ///Setit as the frameandevent providersforAppCallbackNotifier
    
17. ///@remarks setEventProvider API takesina bit mask of eventsforregistering a providerforthe different events
    
18. ///That way,ifevents can come from DisplayAdapterinfuture,we will be abletoadd it as provider
    
19. ///forany event
    
20. mAppCallbackNotifier->setEventProvider(eventMask,mCameraAdapter);
    
21. mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
    
22. 
    
23. ///Any dynamic errors that happen during the camera usecasehastobe propagated backtothe application
    
24. ///via CAMERA_MSG_ERROR.AppCallbackNotifieristheclassthat notifies such errorstothe application
    
25. ///Setit as theerrorhandlerforCameraAdapter
    
26. mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
    
27. 
    
28. ///Start the callback notifier
    
29. if(mAppCallbackNotifier->start()!=NO_ERROR)
    
30. {
    
31. CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
    
32. goto fail_loop;
    
33. }
    
34. 
    
35. CAMHAL_LOGDA("Started AppCallbackNotifier..");
    
36. mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
    

4.这里很重要*****************************************************************************
这里进行camera参数的设置

1. ///Initialize default parameters
   
2. initDefaultParameters();
   
3. 
   
4. if(setParameters(mParameters)!=NO_ERROR)
   
5. {
   
6. CAMHAL_LOGEA("Failed to set default parameters?!");
   
7. }
   

5.这里很重要*****************************************************************************
这里实例化一个SensorListener，并且调用initialize方法进行初始化，以及其他一些初始设置

1. //registerforsensor events
   
2. mSensorListener=new SensorListener();
   
3. if(mSensorListener.get()){
   
4. if(mSensorListener->initialize()==NO_ERROR){
   
5. mSensorListener->setCallbacks(orientation_cb,this);
   
6. mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
   
7. }else{
   
8. CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
   
9. mSensorListener.clear();
   
10. mSensorListener=NULL;
    
11. }
    
12. }
    
13. 
    
14. LOG_FUNCTION_NAME_EXIT;
    
15. 
    
16. return NO_ERROR;
    
17. 
    
18. fail_loop:
    
19. 
    
20. ///Free up the resources because we failed somewhere up
    
21. deinitialize();
    
22. LOG_FUNCTION_NAME_EXIT;
    
23. 
    
24. return NO_MEMORY;
    
25. 
    
26. }

上面一共五个步骤，接下来将一一分析，自我感觉很有这样的必要

一.OMXCameraAdapter的实例化和初始化
首先看一下OMXCameraAdapter的默认构造函数

1. OMXCameraAdapter::OMXCameraAdapter(size_t sensor_index)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. 
   
5. mOmxInitialized=false;
   
6. mComponentState=OMX_StateInvalid;
   
7. mSensorIndex=sensor_index;
   
8. mPictureRotation=0;
   
9. //Initial values
   
10. mTimeSourceDelta=0;
    
11. onlyOnce=true;
    
12. mDccData.pData=NULL;
    
13. 
    
14. mInitSem.Create(0);
    
15. mFlushSem.Create(0);
    
16. mUsePreviewDataSem.Create(0);
    
17. mUsePreviewSem.Create(0);
    
18. mUseCaptureSem.Create(0);
    
19. mUseReprocessSem.Create(0);
    
20. mStartPreviewSem.Create(0);
    
21. mStopPreviewSem.Create(0);
    
22. mStartCaptureSem.Create(0);
    
23. mStopCaptureSem.Create(0);
    
24. mStopReprocSem.Create(0);
    
25. mSwitchToLoadedSem.Create(0);
    
26. mCaptureSem.Create(0);
    
27. 
    
28. mSwitchToExecSem.Create(0);
    
29. 
    
30. mCameraAdapterParameters.mHandleComp=0;
    
31. 
    
32. mUserSetExpLock=OMX_FALSE;
    
33. mUserSetWbLock=OMX_FALSE;
    
34. 
    
35. mFramesWithDucati=0;
    
36. mFramesWithDisplay=0;
    
37. mFramesWithEncoder=0;
    
38. 
    
39. #ifdef CAMERAHAL_OMX_PROFILING
    
40. 
    
41. mDebugProfile=0;
    
42. 
    
43. #endif
    
44. 
    
45. LOG_FUNCTION_NAME_EXIT;
    
46. }

这其中只是对很多参数的默认初始化，接下来看看initialize方法

1. /*--------------------Camera AdapterClassSTARTS here-----------------------------*/
   
2. 
   
3. status_t OMXCameraAdapter::initialize(CameraProperties::Properties*caps)
   
4. {
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. char value[PROPERTY_VALUE_MAX];
   
8. constchar*mountOrientationString=NULL;
   
9. 
   
10. property_get("debug.camera.showfps",value,"0");
    
11. mDebugFps=atoi(value);
    
12. property_get("debug.camera.framecounts",value,"0");
    
13. mDebugFcs=atoi(value);
    
14. 
    
15. #ifdef CAMERAHAL_OMX_PROFILING
    
16. 
    
17. property_get("debug.camera.profile",value,"0");
    
18. mDebugProfile=atoi(value);
    
19. 
    
20. #endif
    
21. 
    
22. TIMM_OSAL_ERRORTYPE osalError=OMX_ErrorNone;
    
23. OMX_ERRORTYPE eError=OMX_ErrorNone;
    
24. status_t ret=NO_ERROR;
    
25. 
    
26. mLocalVersionParam.s.nVersionMajor=0x1;
    
27. mLocalVersionParam.s.nVersionMinor=0x1;
    
28. mLocalVersionParam.s.nRevision=0x0;
    
29. mLocalVersionParam.s.nStep=0x0;
    
30. 
    
31. mPending3Asettings=0;//E3AsettingsAll;
    
32. mPendingCaptureSettings=0;
    
33. mPendingPreviewSettings=0;
    
34. 
    
35. if(0!=mInitSem.Count())
    
36. {
    
37. CAMHAL_LOGEB("Error mInitSem semaphore count %d",mInitSem.Count());
    
38. LOG_FUNCTION_NAME_EXIT;
    
39. return NO_INIT;
    
40. }
    
41. 
    
42. ///Update the previewandimage capture port indexes
    
43. mCameraAdapterParameters.mPrevPortIndex=OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
    
44. //temp changedinordertobuild OMX_CAMERA_PORT_VIDEO_OUT_IMAGE;
    
45. mCameraAdapterParameters.mImagePortIndex=OMX_CAMERA_PORT_IMAGE_OUT_IMAGE;
    
46. mCameraAdapterParameters.mMeasurementPortIndex=OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT;
    
47. //currentlynotsupported use preview port instead
    
48. mCameraAdapterParameters.mVideoPortIndex=OMX_CAMERA_PORT_VIDEO_OUT_VIDEO;
    
49. mCameraAdapterParameters.mVideoInPortIndex=OMX_CAMERA_PORT_VIDEO_IN_VIDEO;
    
50. //1.OMX_Init
    
51. eError=OMX_Init();
52. if(eError!=OMX_ErrorNone){
    
53. CAMHAL_LOGEB("OMX_Init() failed, error: 0x%x",eError);
    
54. return ErrorUtils::omxToAndroidError(eError);
    
55. }
    
56. mOmxInitialized=true;
    
57. 
    
58. //2.Initialize the callback handles
    
59. OMX_CALLBACKTYPE callbacks;
    
60. callbacks.EventHandler=android::OMXCameraAdapterEventHandler;
    
61. callbacks.EmptyBufferDone=android::OMXCameraAdapterEmptyBufferDone;
    
62. callbacks.FillBufferDone=android::OMXCameraAdapterFillBufferDone;
    
63. 
    
64. // 3.Getthe handletothe OMX Component
    
65. eError=OMXCameraAdapter::OMXCameraGetHandle(&mCameraAdapterParameters.mHandleComp,this,callbacks);
    
66. if(eError!=OMX_ErrorNone){
    
67. CAMHAL_LOGEB("OMX_GetHandle -0x%x",eError);
    
68. }
    
69. GOTO_EXIT_IF((eError!=OMX_ErrorNone),eError);
    
70. 
    
71. mComponentState=OMX_StateLoaded;
    
72. 
    
73. CAMHAL_LOGVB("OMX_GetHandle -0x%x sensor_index = %lu",eError,mSensorIndex);
    
74. initDccFileDataSave(&mCameraAdapterParameters.mHandleComp,mCameraAdapterParameters.mPrevPortIndex);
    
75. 
    
76. eError=OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
    
77. OMX_CommandPortDisable,
    
78. OMX_ALL,
    
79. NULL);
    
80. 
    
81. if(eError!=OMX_ErrorNone){
    
82. CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x",eError);
    
83. }
    
84. GOTO_EXIT_IF((eError!=OMX_ErrorNone),eError);
    
85. 
    
86. //4.Registerforport enable event
    
87. ret=RegisterForEvent(mCameraAdapterParameters.mHandleComp,
    
88. OMX_EventCmdComplete,
    
89. OMX_CommandPortEnable,
    
90. mCameraAdapterParameters.mPrevPortIndex,
    
91. mInitSem);
    
92. if(ret!=NO_ERROR){
    
93. CAMHAL_LOGEB("Error in registering for event %d",ret);
    
94. gotoEXIT;
    
95. }
    
96. 
    
97. //5.Enable PREVIEW Port
    
98. eError=OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
    
99. OMX_CommandPortEnable,
    
100. mCameraAdapterParameters.mPrevPortIndex,
     
101. NULL);
     
102. if(eError!=OMX_ErrorNone){
     
103. CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x",eError);
     
104. }
     
105. GOTO_EXIT_IF((eError!=OMX_ErrorNone),eError);
     
106. 
     
107. //6.Waitforthe port enable eventtooccur
     
108. ret=mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
     
109. if(NO_ERROR==ret){
     
110. CAMHAL_LOGDA("-Port enable event arrived");
     
111. }else{
     
112. ret|=RemoveEvent(mCameraAdapterParameters.mHandleComp,
     
113. OMX_EventCmdComplete,
     
114. OMX_CommandPortEnable,
     
115. mCameraAdapterParameters.mPrevPortIndex,
     
116. NULL);
     
117. CAMHAL_LOGEA("Timeout for enabling preview port expired!");
     
118. gotoEXIT;
     
119. }
     
120. 
     
121. //7.Selectthesensor
     
122. OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
     
123. OMX_INIT_STRUCT_PTR(&sensorSelect,OMX_CONFIG_SENSORSELECTTYPE);
     
124. sensorSelect.eSensor=(OMX_SENSORSELECT)mSensorIndex;
     
125. eError=OMX_SetConfig(mCameraAdapterParameters.mHandleComp,(OMX_INDEXTYPE)OMX_TI_IndexConfigSensorSelect,&sensorSelect);
     
126. if(OMX_ErrorNone!=eError){
     
127. CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x",mSensorIndex,eError);
     
128. return BAD_VALUE;
     
129. }else{
     
130. CAMHAL_LOGDB("Sensor %d selected successfully",mSensorIndex);
     
131. }
     
132. 
     
133. #ifdef CAMERAHAL_DEBUG
     
134. 
     
135. printComponentVersion(mCameraAdapterParameters.mHandleComp);
     
136. 
     
137. #endif
     
138. // 8.初始化默认参数
     
139. mBracketingEnabled=false;
     
140. mZoomBracketingEnabled=false;
     
141. mBracketingBuffersQueuedCount=0;
     
142. mBracketingRange=1;
     
143. mLastBracetingBufferIdx=0;
     
144. mBracketingBuffersQueued=NULL;
     
145. mOMXStateSwitch=false;
     
146. mBracketingSet=false;
     
147. #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING
     
148. mRawCapture=false;
     
149. mYuvCapture=false;
     
150. #endif
     
151. 
     
152. mCaptureSignalled=false;
     
153. mCaptureConfigured=false;
     
154. mReprocConfigured=false;
     
155. mRecording=false;
     
156. mWaitingForSnapshot=false;
     
157. mPictureFormatFromClient=NULL;
     
158. 
     
159. mCapabilitiesOpMode=MODE_MAX;
     
160. mCapMode=INITIAL_MODE;
     
161. mIPP=IPP_NULL;
     
162. mVstabEnabled=false;
     
163. mVnfEnabled=false;
     
164. mBurstFrames=1;
     
165. mBurstFramesAccum=0;
     
166. mCapturedFrames=0;
     
167. mFlushShotConfigQueue=false;
     
168. mPictureQuality=100;
     
169. mCurrentZoomIdx=0;
     
170. mTargetZoomIdx=0;
     
171. mPreviousZoomIndx=0;
     
172. mReturnZoomStatus=false;
     
173. mZoomInc=1;
     
174. mZoomParameterIdx=0;
     
175. mExposureBracketingValidEntries=0;
     
176. mZoomBracketingValidEntries=0;
     
177. mSensorOverclock=false;
     
178. mAutoConv=OMX_TI_AutoConvergenceModeMax;
     
179. mManualConv=0;
     
180. mDeviceOrientation=0;
     
181. mCapabilities=caps;
     
182. mZoomUpdating=false;
     
183. mZoomUpdate=false;
     
184. mGBCE=BRIGHTNESS_OFF;
     
185. mGLBCE=BRIGHTNESS_OFF;
     
186. mParameters3A.ExposureLock=OMX_FALSE;
     
187. mParameters3A.WhiteBalanceLock=OMX_FALSE;
     
188. 
     
189. mEXIFData.mGPSData.mAltitudeValid=false;
     
190. mEXIFData.mGPSData.mDatestampValid=false;
     
191. mEXIFData.mGPSData.mLatValid=false;
     
192. mEXIFData.mGPSData.mLongValid=false;
     
193. mEXIFData.mGPSData.mMapDatumValid=false;
     
194. mEXIFData.mGPSData.mProcMethodValid=false;
     
195. mEXIFData.mGPSData.mVersionIdValid=false;
     
196. mEXIFData.mGPSData.mTimeStampValid=false;
     
197. mEXIFData.mModelValid=false;
     
198. mEXIFData.mMakeValid=false;
     
199. 
     
200. //update the mDeviceOrientation with the sensor mount orientation.
     
201. //So that the face detect will work before onOrientationEvent()
     
202. //gettriggered.
     
203. CAMHAL_ASSERT(mCapabilities);
     
204. mountOrientationString=mCapabilities->get(CameraProperties::ORIENTATION_INDEX);
     
205. CAMHAL_ASSERT(mountOrientationString);
     
206. mDeviceOrientation=atoi(mountOrientationString);
     
207. 
     
208. if(mSensorIndex!=2){
     
209. mCapabilities->setMode(MODE_HIGH_SPEED);
     
210. }
     
211. 
     
212. if(mCapabilities->get(CameraProperties::SUPPORTED_ZOOM_STAGES)!=NULL){
     
213. mMaxZoomSupported=mCapabilities->getInt(CameraProperties::SUPPORTED_ZOOM_STAGES)+1;
     
214. }else{
     
215. mMaxZoomSupported=1;
     
216. }
     
217. 
     
218. //9.initialize command handling thread
     
219. if(mCommandHandler.get()==NULL)
     
220. mCommandHandler=new CommandHandler(this);
     
221. 
     
222. if(NULL==mCommandHandler.get())
     
223. {
     
224. CAMHAL_LOGEA("Couldn't create command handler");
     
225. return NO_MEMORY;
     
226. }
     
227. 
     
228. ret=mCommandHandler->run("CallbackThread",PRIORITY_URGENT_DISPLAY);
     
229. if(ret!=NO_ERROR)
     
230. {
     
231. if(ret==INVALID_OPERATION){
     
232. CAMHAL_LOGDA("command handler thread already runnning!!");
     
233. ret=NO_ERROR;
     
234. }else{
     
235. CAMHAL_LOGEA("Couldn't run command handlerthread");
     
236. return ret;
     
237. }
     
238. }
     
239. 
     
240. //10.initialize omx callback handling thread
     
241. if(mOMXCallbackHandler.get()==NULL)
     
242. mOMXCallbackHandler=new OMXCallbackHandler(this);
     
243. 
     
244. if(NULL==mOMXCallbackHandler.get())
     
245. {
     
246. CAMHAL_LOGEA("Couldn't create omx callback handler");
     
247. return NO_MEMORY;
     
248. }
     
249. 
     
250. ret=mOMXCallbackHandler->run("OMXCallbackThread",PRIORITY_URGENT_DISPLAY);
     
251. if(ret!=NO_ERROR)
     
252. {
     
253. if(ret==INVALID_OPERATION){
     
254. CAMHAL_LOGDA("omx callback handler thread already runnning!!");
     
255. ret=NO_ERROR;
     
256. }else{
     
257. CAMHAL_LOGEA("Couldn't run omx callback handler thread");
     
258. return ret;
     
259. }
     
260. }
     
261. 
     
262. OMX_INIT_STRUCT_PTR(&mRegionPriority,OMX_TI_CONFIG_3A_REGION_PRIORITY);
     
263. OMX_INIT_STRUCT_PTR(&mFacePriority,OMX_TI_CONFIG_3A_FACE_PRIORITY);
     
264. mRegionPriority.nPortIndex=OMX_ALL;
     
265. mFacePriority.nPortIndex=OMX_ALL;
     
266. 
     
267. //Setting this flag will that the first setParametercallwill apply all 3A settings
     
268. //andwillnotconditionally apply basedoncurrent values.
     
269. mFirstTimeInit=true;
     
270. 
     
271. //Flagtoavoid calling setVFramerate()before OMX_SetParameter(OMX_IndexParamPortDefinition)
     
272. //Ducati will return anerrorotherwise.
     
273. mSetFormatDone=false;
     
274. 
     
275. memset(mExposureBracketingValues,0,EXP_BRACKET_RANGE*sizeof(int));
     
276. memset(mZoomBracketingValues,0,ZOOM_BRACKET_RANGE*sizeof(int));
     
277. mMeasurementEnabled=false;
     
278. mFaceDetectionRunning=false;
     
279. mFaceDetectionPaused=false;
     
280. mFDSwitchAlgoPriority=false;
     
281. 
     
282. memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex],0,sizeof(OMXCameraPortParameters));
     
283. memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex],0,sizeof(OMXCameraPortParameters));
     
284. memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex],0,sizeof(OMXCameraPortParameters));
     
285. memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoInPortIndex],0,sizeof(OMXCameraPortParameters));
     
286. 
     
287. //11.initialize 3A defaults
     
288. mParameters3A.Effect=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT,EffLUT);
     
289. mParameters3A.FlashMode=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE,FlashLUT);
     
290. mParameters3A.SceneMode=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE,SceneLUT);
     
291. mParameters3A.EVCompensation=atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION);
     
292. mParameters3A.Focus=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE,FocusLUT);
     
293. mParameters3A.ISO=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE,IsoLUT);
     
294. mParameters3A.Flicker=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING,FlickerLUT);
     
295. mParameters3A.Brightness=atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS);
     
296. mParameters3A.Saturation=atoi(OMXCameraAdapter::DEFAULT_SATURATION)-SATURATION_OFFSET;
     
297. mParameters3A.Sharpness=atoi(OMXCameraAdapter::DEFAULT_SHARPNESS)-SHARPNESS_OFFSET;
     
298. mParameters3A.Contrast=atoi(OMXCameraAdapter::DEFAULT_CONTRAST)-CONTRAST_OFFSET;
     
299. mParameters3A.WhiteBallance=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB,WBalLUT);
     
300. mParameters3A.Exposure=getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE,ExpLUT);
     
301. mParameters3A.ExposureLock=OMX_FALSE;
     
302. mParameters3A.FocusLock=OMX_FALSE;
     
303. mParameters3A.WhiteBalanceLock=OMX_FALSE;
     
304. 
     
305. mParameters3A.ManualExposure=0;
     
306. mParameters3A.ManualExposureRight=0;
     
307. mParameters3A.ManualGain=0;
     
308. mParameters3A.ManualGainRight=0;
     
309. 
     
310. mParameters3A.AlgoFixedGamma=OMX_TRUE;
     
311. mParameters3A.AlgoNSF1=OMX_TRUE;
     
312. mParameters3A.AlgoNSF2=OMX_TRUE;
     
313. mParameters3A.AlgoSharpening=OMX_TRUE;
     
314. mParameters3A.AlgoThreeLinColorMap=OMX_TRUE;
     
315. mParameters3A.AlgoGIC=OMX_TRUE;
     
316. 
     
317. LOG_FUNCTION_NAME_EXIT;
     
318. return ErrorUtils::omxToAndroidError(eError);
     
319. 
     
320. EXIT:
     
321. 
     
322. CAMHAL_LOGDB("Exiting function %s because of ret %d eError=%x",__FUNCTION__,ret,eError);
     
323. performCleanupAfterError();
     
324. LOG_FUNCTION_NAME_EXIT;
     
325. return ErrorUtils::omxToAndroidError(eError);
     
326. }

这个initialize的过程做的事情还是比较多的，这里关系到OMX的很多知识点，是之后要研究的，现在只是先知道这里
在完成initialize方法之后，
mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
这两个方法同样非常重要，首先我们这里调用的是mCameraAdapter的方法， mCameraAdapter是OMXCameraAdapter这个类的实例，但是其实 OMXCameraAdapter这个类中是没有以上这两个方法的，但是我们接着看， OMXCameraAdapter这个类的定义
class OMXCameraAdapter : public BaseCameraAdapter
OMXCameraAdapter继承于BaseCameraAdapter，不错，上面的两个方法是在 BaseCameraAdapter这个类中实现的，我们接着看看

1. status_t BaseCameraAdapter::registerImageReleaseCallback(release_image_buffers_callback callback,void*user_data)
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. mReleaseImageBuffersCallback=callback;
   
8. mReleaseData=user_data;
   
9. 
   
10. LOG_FUNCTION_NAME_EXIT;
    
11. 
    
12. return ret;
    
13. }
    
14. 
    
15. status_t BaseCameraAdapter::registerEndCaptureCallback(end_image_capture_callback callback,void*user_data)
    
16. {
    
17. status_t ret=NO_ERROR;
    
18. 
    
19. LOG_FUNCTION_NAME;
    
20. 
    
21. mEndImageCaptureCallback=callback;
    
22. mEndCaptureData=user_data;
    
23. 
    
24. LOG_FUNCTION_NAME_EXIT;
    
25. 
    
26. return ret;
    
27. }

这两个方法实现方式一模一样，只是将传入的函数指针和user_data保存到其中而已
mEndImageCaptureCallback这个方法会在OMXCameraAdapter的fillThisBuffer中被调用，他的实现在

1. void releaseImageBuffers(void*userData)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. 
   
5. if(NULL!=userData){
   
6. CameraHal*c=reinterpret_cast<CameraHal*>(userData);//user_data就是指向我们实例化的OMXCameraAdapter变量mCameraAdapter
   
7. c->freeImageBufs();//接着调用mCameraAdapter的freeImageBufs方法
   
8. }
   
9. 
   
10. LOG_FUNCTION_NAME_EXIT;
    
11. }

1. status_t CameraHal::freeImageBufs()
   
2. {
   
3. status_t ret=NO_ERROR;
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. if(NO_ERROR==ret)
   
8. {
   
9. 
   
10. if(NULL!=mImageBufs)
    
11. {
    
12. 
    
13. ///@todo Pluralise the name of this methodtofreeBuffers
    
14. ret=mMemoryManager->freeBuffer(mImageBufs);//通过memoryManager释放内存
    
15. mImageBufs=NULL;
    
16. 
    
17. }
    
18. else
    
19. {
    
20. ret=-EINVAL;
    
21. }
    
22. 
    
23. }
    
24. 
    
25. LOG_FUNCTION_NAME_EXIT;
    
26. 
    
27. return ret;
    
28. }

mReleaseImageBuffersCallback这个方法将在OMXCapture.cpp中被调用，他的实现和上面是相似的，就不再说了

二.AppCallbackNotifier的实例化和初始化
AppCallbackNotifier这个类是没有实现构造函数的，我们就先看看他的initialize方法吧

1. /**
   
2. *NotificationHandlerclass
   
3. */
   
4. 
   
5. ///InitializationfunctionforAppCallbackNotifier
   
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. }

这个initialize方法做的事情相对简单但是有及其重要，他创建了一个notificationthread，然后运行这个thread
这里我们看看这个很忙碌的线程都干了些什么事情，之所以说他忙碌，是因为他一直不停的等待消息，有消息就处理，不能磨叽磨叽的

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. //上面等待message，消息到来时开始往下运行，之后区分这些消息到底是什么消息，就像邮局收到邮件接着往下分发一样
    
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();//先进行消息的筛选，这里跳出有问题的邮件抛弃掉，收到NOTIFIER_EXIT消息则退出
    
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();//分类完成就分类处理了，这里是enent 事件的处理
    
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();//分类完成就分类处理了，这里是frame 事件的处理
    
36. }
    
37. 
    
38. LOG_FUNCTION_NAME_EXIT;
    
39. return shouldLive;
    
40. }

这里先看一下notifyEvent方法的处理过程：

1. void AppCallbackNotifier::notifyEvent()
   
2. {
   
3. ///Receiveandsend the event notificationstoapp
   
4. TIUTILS::Message msg;
   
5. LOG_FUNCTION_NAME;
   
6. {
   
7. Mutex::Autolock lock(mLock);
   
8. if(!mEventQ.hasMsg()){
   
9. return;
   
10. }else{
    
11. mEventQ.get(&msg);
    
12. }
    
13. }
    
14. bool ret=true;
    
15. CameraHalEvent*evt=NULL;
    
16. CameraHalEvent::FocusEventData*focusEvtData;
    
17. CameraHalEvent::ZoomEventData*zoomEvtData;
    
18. CameraHalEvent::MetaEventData metaEvtData;
    
19. 
    
20. if(mNotifierState!=AppCallbackNotifier::NOTIFIER_STARTED)
    
21. {
    
22. return;
    
23. }
    
24. 
    
25. switch(msg.command)
    
26. {
    
27. caseAppCallbackNotifier::NOTIFIER_CMD_PROCESS_EVENT:
    
28. 
    
29. evt=(CameraHalEvent*)msg.arg1;
    
30. 
    
31. if(NULL==evt)
    
32. {
    
33. CAMHAL_LOGEA("Invalid CameraHalEvent");
    
34. return;
    
35. }
    
36. 
    
37. switch(evt->mEventType)
    
38. {
    
39. caseCameraHalEvent::EVENT_SHUTTER:
    
40. 
    
41. if((NULL!=mCameraHal)&&
    
42. (NULL!=mNotifyCb)&&
    
43. (mCameraHal->msgTypeEnabled(CAMERA_MSG_SHUTTER)))
    
44. {
    
45. mNotifyCb(CAMERA_MSG_SHUTTER,0,0,mCallbackCookie);
    
46. }
    
47. mRawAvailable=false;
    
48. 
    
49. break;
    
50. 
    
51. caseCameraHalEvent::EVENT_FOCUS_LOCKED:
    
52. caseCameraHalEvent::EVENT_FOCUS_ERROR:
    
53. 
    
54. focusEvtData=&evt->mEventData->focusEvent;
    
55. if((focusEvtData->focusStatus==CameraHalEvent::FOCUS_STATUS_SUCCESS)&&
    
56. (NULL!=mCameraHal)&&
    
57. (NULL!=mNotifyCb)&&
    
58. (mCameraHal->msgTypeEnabled(CAMERA_MSG_FOCUS))){
    
59. mCameraHal->disableMsgType(CAMERA_MSG_FOCUS);
    
60. mNotifyCb(CAMERA_MSG_FOCUS,true,0,mCallbackCookie);
    
61. }elseif((focusEvtData->focusStatus==CameraHalEvent::FOCUS_STATUS_FAIL)&&
    
62. (NULL!=mCameraHal)&&
    
63. (NULL!=mNotifyCb)&&
    
64. (mCameraHal->msgTypeEnabled(CAMERA_MSG_FOCUS))){
    
65. mCameraHal->disableMsgType(CAMERA_MSG_FOCUS);
    
66. mNotifyCb(CAMERA_MSG_FOCUS,false,0,mCallbackCookie);
    
67. }
    
68. 
    
69. break;
    
70. 
    
71. caseCameraHalEvent::EVENT_ZOOM_INDEX_REACHED:
    
72. 
    
73. zoomEvtData=&evt->mEventData->zoomEvent;
    
74. 
    
75. if((NULL!=mCameraHal)&&
    
76. (NULL!=mNotifyCb)&&
    
77. (mCameraHal->msgTypeEnabled(CAMERA_MSG_ZOOM)))
    
78. {
    
79. mNotifyCb(CAMERA_MSG_ZOOM,zoomEvtData->currentZoomIndex,zoomEvtData->targetZoomIndexReached,mCallbackCookie);
    
80. }
    
81. 
    
82. break;
    
83. 
    
84. caseCameraHalEvent::EVENT_METADATA:
    
85. 
    
86. metaEvtData=evt->mEventData->metadataEvent;
    
87. 
    
88. if((NULL!=mCameraHal)&&
    
89. (NULL!=mNotifyCb)&&
    
90. (mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_METADATA)))
    
91. {
    
92. //WAforan issue inside CameraService
    
93. camera_memory_t*tmpBuffer=mRequestMemory(-1,1,1,NULL);
    
94. 
    
95. mDataCb(CAMERA_MSG_PREVIEW_METADATA,
    
96. tmpBuffer,
    
97. 0,
    
98. metaEvtData->getMetadataResult(),
    
99. mCallbackCookie);
    
100. 
     
101. metaEvtData.clear();
     
102. 
     
103. if(NULL!=tmpBuffer){
     
104. tmpBuffer->release(tmpBuffer);
     
105. }
     
106. 
     
107. }
     
108. 
     
109. break;
     
110. 
     
111. caseCameraHalEvent::ALL_EVENTS:
     
112. break;
     
113. default:
     
114. break;
     
115. }
     
116. 
     
117. break;
     
118. }
     
119. 
     
120. if(NULL!=evt)
     
121. {
     
122. delete evt;
     
123. }
     
124. 
     
125. 
     
126. LOG_FUNCTION_NAME_EXIT;
     
127. 
     
128. }

针对每个不同消息处理方法基本是相同的，主要通过上次register好的callback方法，这个之前已经在文章中说过，不在多做说明
这里还是比较重要的，但不是这篇文章的重点，之后有机会还会在说
再看一下 notifyFrame的处理过程：
算了，我还是不把他的处理过程贴出来，怕吓到人，挺庞大的，处理了很多事件，当然重要，先知道，再看吧

这里你处理了notifyEvent和notifyFrame这里消息，但是这些消息是从哪里来呢？知道了接收者，那么就必须找到发送者
mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
不错，就是在这里指定了enent和frame消息的提供者（provider）
先看看setEventProvider的实现

1. void AppCallbackNotifier::setEventProvider(int32_t eventMask,MessageNotifier*eventNotifier)
   
2. {
   
3. 
   
4. LOG_FUNCTION_NAME;
   
5. ///@remarks ThereisnoNULLcheck here.We will check
   
6. ///forNULLwhen wegetstart command from CameraHal
   
7. ///@Remarks Currently only one event provider(CameraAdapter)issupported
   
8. ///@todo Have anarrayof event providersforeachevent bitmask
   
9. mEventProvider=new EventProvider(eventNotifier,this,eventCallbackRelay);
   
10. if(NULL==mEventProvider)
    
11. {
    
12. CAMHAL_LOGEA("Error in creating EventProvider");
    
13. }
    
14. else
    
15. {
    
16. mEventProvider->enableEventNotification(eventMask);
    
17. }
    
18. 
    
19. LOG_FUNCTION_NAME_EXIT;
    
20. }

实例化了一个EnentProvider的对象，并且enable EventNotification
再看看setFrameProvider的实现吧

1. void AppCallbackNotifier::setFrameProvider(FrameNotifier*frameNotifier)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. ///@remarks ThereisnoNULLcheck here.We will check
   
5. ///forNULLwhen wegetthe 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 onlyforcaptured imagesandRAWfornow
    
14. //TODO:Registerforandhandle 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 FrameNotification
但是这里必须分析一下FrameProvider的构造方法

1. FrameProvider(FrameNotifier*fn,void*cookie,frame_callback frameCallback)
   
2. :mFrameNotifier(fn),mCookie(cookie),mFrameCallback(frameCallback){}

这里通过传入的参数实例化了mFrameNotifier，初始化了mCookie，初始化了mFrameCallback，看似没什么却至关只要啊，后面你会知道的，同样EventProvider同样的

FrameProvider和EnentProvider接口的实现在CameraHalUtilClasses.cpp文件
接着往下走：Start the callback notifier
mAppCallbackNotifier->start()

1. status_t AppCallbackNotifier::start()
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. if(mNotifierState==AppCallbackNotifier::NOTIFIER_STARTED)
   
5. {
   
6. CAMHAL_LOGDA("AppCallbackNotifier already running");
   
7. LOG_FUNCTION_NAME_EXIT;
   
8. return ALREADY_EXISTS;
   
9. }
   
10. 
    
11. ///Check whether initial conditions are metforustostart
    
12. ///A frame provider should be available,ifnotreturnerror
    
13. if(!mFrameProvider)
    
14. {
    
15. ///AppCallbackNotifiernotproperly initialized
    
16. CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Frame provider is NULL");
    
17. LOG_FUNCTION_NAME_EXIT;
    
18. return NO_INIT;
    
19. }
    
20. 
    
21. ///At least one event notifier should be available,ifnotreturnerror
    
22. ///@todo Modify here when thereisanarrayof event providers
    
23. if(!mEventProvider)
    
24. {
    
25. CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Event provider is NULL");
    
26. LOG_FUNCTION_NAME_EXIT;
    
27. ///AppCallbackNotifiernotproperly initialized
    
28. return NO_INIT;
    
29. }
    
30. 
    
31. mNotifierState=AppCallbackNotifier::NOTIFIER_STARTED;
    
32. CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STARTED \n");
    
33. 
    
34. gEncoderQueue.clear();
    
35. 
    
36. LOG_FUNCTION_NAME_EXIT;
    
37. 
    
38. return NO_ERROR;
    
39. 
    
40. }

只是做了一下检查，最后clear了编码队列
接着走：mAppCallbackNotifier->setMeasurements

1. void AppCallbackNotifier::setMeasurements(bool enable)
   
2. {
   
3. Mutex::Autolock lock(mLock);
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. mMeasurementEnabled=enable;
   
8. 
   
9. if(enable)
   
10. {
    
11. mFrameProvider->enableFrameNotification(CameraFrame::FRAME_DATA_SYNC);
    
12. }
    
13. 
    
14. LOG_FUNCTION_NAME_EXIT;
    
15. }

AppCallbackNotifier对象实例化以及初始化到这里完成了

三.MemoryManager的实例化和初始化
无疑这个类跟内存有着很密切的关系，这个定义了自己的构造函数，但是这里不说了，是在大财小用了，只一条语句，直接看看他的initialize方法吧

1. status_t MemoryManager::initialize(){
   
2. if(mIonFd==-1){
   
3. mIonFd=ion_open();
   
4. if(mIonFd<0){
   
5. CAMHAL_LOGE("ion_open() failed, error: %d",mIonFd);
   
6. mIonFd=-1;
   
7. return NO_INIT;
   
8. }
   
9. }
   
10. 
    
11. return OK;
    
12. }

只是调用了 ion_open这个方法获得了一个fd

1. intion_open()
   
2. {
   
3. intfd=open("/dev/ion",O_RDWR);
   
4. if(fd<0)
   
5. LOGE("open /dev/ion failed!\n");
   
6. return fd;
   
7. }

开始时我晕了，ion到底是什么device啊？赶紧查一查
这里我不做过多说明，可以看看这个分享，同时感谢大牛的分享： http://blog.csdn.net/melody_lu123/article/details/7556820
ION与PMEM类似，管理一或多个内存池，其中有一些会在boot time的时候预先分配，以备给特殊的硬件使用（GPU，显示控制器等）。它通过ION heaps来管理这些pool。
它可以被userspace的process之间或者内核中的模块之间进行内存共享

四.SensorListener的实例化和初始化
在SensorListener的构造函数中对一些参数进行了默认初始化，这里不知说明，直接看看他的initialize方法实现

1. status_t SensorListener::initialize(){
   
2. status_t ret=NO_ERROR;
   
3. SensorManager&mgr(SensorManager::getInstance());
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. sp<Looper>mLooper;
   
8. 
   
9. mSensorEventQueue=mgr.createEventQueue();
   
10. if(mSensorEventQueue==NULL){
    
11. CAMHAL_LOGEA("createEventQueue returned NULL");
    
12. ret=NO_INIT;
    
13. goto out;
    
14. }
    
15. 
    
16. mLooper=new Looper(false);
    
17. mLooper->addFd(mSensorEventQueue->getFd(),0,ALOOPER_EVENT_INPUT,sensor_events_listener,this);
    
18. 
    
19. if(mSensorLooperThread.get()==NULL)
    
20. mSensorLooperThread=new SensorLooperThread(mLooper.get());
    
21. 
    
22. if(mSensorLooperThread.get()==NULL){
    
23. CAMHAL_LOGEA("Couldn't create sensor looper thread");
    
24. ret=NO_MEMORY;
    
25. goto out;
    
26. }
    
27. 
    
28. ret=mSensorLooperThread->run("sensor looper thread",PRIORITY_URGENT_DISPLAY);
    
29. if(ret==INVALID_OPERATION){
    
30. CAMHAL_LOGDA("thread already running ?!?");
    
31. }elseif(ret!=NO_ERROR){
    
32. CAMHAL_LOGEA("couldn't run thread");
    
33. goto out;
    
34. }
    
35. 
    
36. out:
    
37. LOG_FUNCTION_NAME_EXIT;
    
38. return ret;
    
39. }

看到这里我个人是感觉这里挺抽象的，这里先简单说明一下，这里首先获取到SensorManager，通过这个 SensorManager创建一个EventQueue，然后实例化一个Looper对象，将这个EventQueue的fd添加到mLooper中，最后创建一个SensorLooperThread，并启动这个线程
下一步：mSensorListener->setCallbacks(orientation_cb, this);

1. void SensorListener::setCallbacks(orientation_callback_t orientation_cb,void*cookie){
   
2. LOG_FUNCTION_NAME;
   
3. 
   
4. if(orientation_cb){
   
5. mOrientationCb=orientation_cb;
   
6. }
   
7. mCbCookie=cookie;
   
8. 
   
9. LOG_FUNCTION_NAME_EXIT;
   
10. }

这里的方法跟上面讲过的setcallback方法其实基本是相通的，注册的这个回调函数是在以下方法中被调用到的

1. void SensorListener::handleOrientation(uint32_t orientation,uint32_t tilt){
   
2. LOG_FUNCTION_NAME;
   
3. 
   
4. Mutex::Autolock lock(&mLock);
   
5. 
   
6. if(mOrientationCb&&(sensorsEnabled&SENSOR_ORIENTATION)){
   
7. mOrientationCb(orientation,tilt,mCbCookie);
   
8. }
   
9. 
   
10. LOG_FUNCTION_NAME_EXIT;
    
11. }

也就低调用一下方法：

1. static void orientation_cb(uint32_t orientation,uint32_t tilt,void*cookie){
   
2. CameraHal*camera=NULL;
   
3. 
   
4. if(cookie){
   
5. camera=(CameraHal*)cookie;//这个cookie（this）指向我们实例化mCameraAdapter
   
6. camera->onOrientationEvent(orientation,tilt);//调用mCameraHal的onOrientationEvent方法
   
7. }
   
8. 
   
9. }

我们接着跟踪下去：

1. /**
   
2. Callbackfunctiontoreceive orientation events from SensorListener
   
3. */
   
4. void CameraHal::onOrientationEvent(uint32_t orientation,uint32_t tilt){
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. if(NULL!=mCameraAdapter){
   
8. mCameraAdapter->onOrientationEvent(orientation,tilt);
   
9. }
   
10. 
    
11. LOG_FUNCTION_NAME_EXIT;
    
12. }

继续，实现在OMXCameraAdapter中

1. void OMXCameraAdapter::onOrientationEvent(uint32_t orientation,uint32_t tilt)
   
2. {
   
3. LOG_FUNCTION_NAME;
   
4. 
   
5. staticconstunsignedintDEGREES_TILT_IGNORE=45;
   
6. 
   
7. //iftilt angleisgreater than DEGREES_TILT_IGNORE
   
8. //we are goingtoignore the orientation returned from
   
9. //sensor.the orientation returned from sensorisnot
   
10. //reliable.Value of DEGREES_TILT_IGNORE may need adjusting
    
11. if(tilt>DEGREES_TILT_IGNORE){
    
12. return;
    
13. }
    
14. 
    
15. intmountOrientation=0;
    
16. bool isFront=false;
    
17. if(mCapabilities){
    
18. constchar*constmountOrientationString=
    
19. mCapabilities->get(CameraProperties::ORIENTATION_INDEX);
    
20. if(mountOrientationString){
    
21. mountOrientation=atoi(mountOrientationString);
    
22. }
    
23. 
    
24. constchar*constfacingString=mCapabilities->get(CameraProperties::FACING_INDEX);
    
25. if(facingString){
    
26. isFront=strcmp(facingString,TICameraParameters::FACING_FRONT)==0;
    
27. }
    
28. }
    
29. 
    
30. //directionisa constant signforfacing,meaning the rotation direction relativetodevice
    
31. //+1(clockwise)forback sensorand-1(counter-clockwise)forfront sensor
    
32. constintdirection=isFront?-1:1;
    
33. 
    
34. introtation=mountOrientation+direction*orientation;
    
35. 
    
36. //crop the calculated valueto[0..360)range
    
37. while(rotation<0)rotation+=360;
    
38. rotation%=360;
    
39. 
    
40. if(rotation!=mDeviceOrientation){
    
41. mDeviceOrientation=rotation;
    
42. 
    
43. //restart face detection with new rotation
    
44. setFaceDetectionOrientation(mDeviceOrientation);
    
45. }
    
46. CAMHAL_LOGVB("orientation = %d tilt = %d device_orientation = %d",orientation,tilt,mDeviceOrientation);
    
47. 
    
48. LOG_FUNCTION_NAME_EXIT;
    
49. }

这里暂时不做分析

最后一步：mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION)

1. void SensorListener::enableSensor(sensor_type_t type){
   
2. Sensorconst*sensor;
   
3. SensorManager&mgr(SensorManager::getInstance());
   
4. 
   
5. LOG_FUNCTION_NAME;
   
6. 
   
7. Mutex::Autolock lock(&mLock);
   
8. 
   
9. if((type&SENSOR_ORIENTATION)&&!(sensorsEnabled&SENSOR_ORIENTATION)){
   
10. sensor=mgr.getDefaultSensor(Sensor::TYPE_ACCELEROMETER);
    
11. CAMHAL_LOGDB("orientation = %p (%s)",sensor,sensor->getName().string());
    
12. mSensorEventQueue->enableSensor(sensor);
    
13. mSensorEventQueue->setEventRate(sensor,ms2ns(100));
    
14. sensorsEnabled|=SENSOR_ORIENTATION;
    
15. }
    
16. 
    
17. LOG_FUNCTION_NAME_EXIT;
    
18. }

使能sensor
到这里为止CameraHal的这个初始化过程完成了，这里个人感觉十分重要，其他的接口实现固然重要，但是清清楚楚的知道这个初始化过程会让你hal与上层和底层的交互先有一个大体的认知，这比你一头扎进去到处乱撞要高效很多

Android Camere Study 待续。。。。

更多相关文章

1. runOnUiThread()方法
2. Android欢迎界面的创建方法
3. Android(安卓)之 getSharedPreferences 和 getPreferences
4. Android编程获取地理位置的经度和纬度实例
5. Android开发学习之WallPaper设置壁纸详细介绍与实例
6. “The project cannot be built until build path errors are re
7. Android中的Menu的简介(翻译自官方文档)——————个人笔记
8. Android(安卓)App调用MediaRecorder实现录音功能的实例
9. Android(安卓)IntentService详解

随机推荐

1. Android联系人数据库全解析（1）
2. android studio五大布局属性小结
3. android知识点:inputType常用取值
4. Android系统自带样式(@android:style/)
5. Android几个面试题的解答
6. Android(安卓)基础入门
7. Android(安卓)TextView的跑马灯效果以及T
8. Android(安卓)text文字阴影设置
9. Android窗口和视图
10. Android的发展历史