用心的文章要转

一、在android中开发人员可以做那些工作？
应用程序开发：利用android提供的强大的sdk，开发出各种各样新颖的应用。
系统开发：在android中Google实现了与硬件无关的所有代码，但是与硬件密切相关的硬件抽象层却没有也无法提供，对于移动设备不同的设备提供商底层硬件是千变万化的，不可能提供统一的硬件驱动以及接口实现，只能提供标准的接口，因此硬件提供商需要自个儿开发设备驱动，
并去实现android框架提供的接口。
二、android框架中Camera系统源码分析
在每个android手机中都有一个Camera应用程序用来实现拍照功能，不同硬件提供商可能会对这个应用程序进行改变来适合自己的UI风格，
这里仅仅分析android原生Camera应用以及框架（Android 4.0）
原生Camera应用代码在Camera.java(android4.0\packages\apps\camera\src\com\android\camera)，这个应该算是Camera系统最上层，应用层的实现。
下面是Camera类部分代码

[java] view plain copy
  1. publicclassCameraextendsActivityBaseimplementsFocusManager.Listener,
  2. View.OnTouchListener,ShutterButton.OnShutterButtonListener,
  3. SurfaceHolder.Callback,ModePicker.OnModeChangeListener,
  4. FaceDetectionListener,CameraPreference.OnPreferenceChangedListener,
  5. LocationManager.Listener,ShutterButton.OnShutterButtonLongPressListener
从上面可以看出，Camera在继承了很多监听接口，用来监听各种事件（对焦事件、用户触摸事件等）。这个应用时继承ActivityBase，
可以重载OnCreate、OnResume等接口，在这些接口中完成相关初始化的工作，基本就是初始化各种监听对象，以及获取相机参数等相关。
比较关键的在doOnResume这个函数中：
[java] view plain copy
  1. @Override
  2. protectedvoiddoOnResume(){
  3. if(mOpenCameraFail||mCameraDisabled)return;
  5. mPausing=false;
  7. mJpegPictureCallbackTime=0;
  8. mZoomValue=0;
  10. //Startthepreviewifitisnotstarted.
  11. if(mCameraState==PREVIEW_STOPPED){
  12. try{
  13. mCameraDevice=Util.openCamera(this,mCameraId);
  14. initializeCapabilities();
  15. resetExposureCompensation();
  16. startPreview();
  17. if(mFirstTimeInitialized)startFaceDetection();
  18. }catch(CameraHardwareExceptione){
  19. Util.showErrorAndFinish(this,R.string.cannot_connect_camera);
  20. return;
  21. }catch(CameraDisabledExceptione){
  22. Util.showErrorAndFinish(this,R.string.camera_disabled);
  23. return;
  24. }
  25. }
  27. if(mSurfaceHolder!=null){
  28. //Iffirsttimeinitializationisnotfinished,putitinthe
  29. //messagequeue.
  30. if(!mFirstTimeInitialized){
  31. mHandler.sendEmptyMessage(FIRST_TIME_INIT);
  32. }else{
  33. initializeSecondTime();
  34. }
  35. }
  36. keepScreenOnAwhile();
  38. if(mCameraState==IDLE){
  39. mOnResumeTime=SystemClock.uptimeMillis();
  40. mHandler.sendEmptyMessageDelayed(CHECK_DISPLAY_ROTATION,100);
  41. }
  42. }
在这个函数中看到通过这个函数获得Camera底层对象
mCameraDevice = Util.openCamera(this, mCameraId)，这里使用Util这个类，这个类的实现在
Util.java (android4.0\packages\apps\camera\src\com\android\camera)中，找到OpenCamera这个函数实现：
[java] view plain copy
  1. publicstaticandroid.hardware.CameraopenCamera(Activityactivity,intcameraId)
  2. throwsCameraHardwareException,CameraDisabledException{
  3. //Checkifdevicepolicyhasdisabledthecamera.
  4. DevicePolicyManagerdpm=(DevicePolicyManager)activity.getSystemService(
  5. Context.DEVICE_POLICY_SERVICE);
  6. if(dpm.getCameraDisabled(null)){
  7. thrownewCameraDisabledException();
  8. }
  10. try{
  11. returnCameraHolder.instance().open(cameraId);
  12. }catch(CameraHardwareExceptione){
  13. //Inengbuild,wethrowtheexceptionsothattesttool
  14. //candetectitandreportit
  15. if("eng".equals(Build.TYPE)){
  16. thrownewRuntimeException("openCamerafailed",e);
  17. }else{
  18. throwe;
  19. }
  20. }
  21. }
从这个函数可以看出，android系统中对下层Camera管理，是通过一个单例模式CameraHolder来管理的，
定位到这个类的实现CameraHolder.java (android4.0\packages\apps\camera\src\com\android\camera)通过调用open函数获取一个Camera硬件设备对象，
因为Camera设备是独享设备，不能同时被两个进程占用，而整个android系统是一个多进程环境，因此需要加入一些进程间互斥同步的方法。
定位到这个类的open函数：
[java] view plain copy
  1. publicsynchronizedandroid.hardware.Cameraopen(intcameraId)
  2. throwsCameraHardwareException{
  3. Assert(mUsers==0);
  4. if(mCameraDevice!=null&&mCameraId!=cameraId){
  5. mCameraDevice.release();
  6. mCameraDevice=null;
  7. mCameraId=-1;
  8. }
  9. if(mCameraDevice==null){
  10. try{
  11. Log.v(TAG,"opencamera"+cameraId);
  12. mCameraDevice=android.hardware.Camera.open(cameraId);
  13. mCameraId=cameraId;
  14. }catch(RuntimeExceptione){
  15. Log.e(TAG,"failtoconnectCamera",e);
  16. thrownewCameraHardwareException(e);
  17. }
  18. mParameters=mCameraDevice.getParameters();
  19. }else{
  20. try{
  21. mCameraDevice.reconnect();
  22. }catch(IOExceptione){
  23. Log.e(TAG,"reconnectfailed.");
  24. thrownewCameraHardwareException(e);
  25. }
  26. mCameraDevice.setParameters(mParameters);
  27. }
  28. ++mUsers;
  29. mHandler.removeMessages(RELEASE_CAMERA);
  30. mKeepBeforeTime=0;
  31. returnmCameraDevice;
  32. }
[java] view plain copy
通过android.hardware.Camera.open(cameraId)调用进入下一层封装，JNI层，这一层是java代码的最下层，对下层CameraC++代码进行JNI封装，封装实现类在Camera.java (android4.0\frameworks\base\core\java\android\hardware) 下面是这个类的部分实现，里面定义了不少回调函数： [java] view plain copy
  1. publicclassCamera{
  2. privatestaticfinalStringTAG="Camera";
  4. //Thesematchtheenumsinframeworks/base/include/camera/Camera.h
  5. privatestaticfinalintCAMERA_MSG_ERROR=0x001;
  6. privatestaticfinalintCAMERA_MSG_SHUTTER=0x002;
  7. privatestaticfinalintCAMERA_MSG_FOCUS=0x004;
  8. privatestaticfinalintCAMERA_MSG_ZOOM=0x008;
  9. privatestaticfinalintCAMERA_MSG_PREVIEW_FRAME=0x010;
  10. privatestaticfinalintCAMERA_MSG_VIDEO_FRAME=0x020;
  11. privatestaticfinalintCAMERA_MSG_POSTVIEW_FRAME=0x040;
  12. privatestaticfinalintCAMERA_MSG_RAW_IMAGE=0x080;
  13. privatestaticfinalintCAMERA_MSG_COMPRESSED_IMAGE=0x100;
  14. privatestaticfinalintCAMERA_MSG_RAW_IMAGE_NOTIFY=0x200;
  15. privatestaticfinalintCAMERA_MSG_PREVIEW_METADATA=0x400;
  16. privatestaticfinalintCAMERA_MSG_ALL_MSGS=0x4FF;
  18. privateintmNativeContext;//accessedbynativemethods
  19. privateEventHandlermEventHandler;
  20. privateShutterCallbackmShutterCallback;
  21. privatePictureCallbackmRawImageCallback;
  22. privatePictureCallbackmJpegCallback;
  23. privatePreviewCallbackmPreviewCallback;
  24. privatePictureCallbackmPostviewCallback;
  25. privateAutoFocusCallbackmAutoFocusCallback;
  26. privateOnZoomChangeListenermZoomListener;
  27. privateFaceDetectionListenermFaceListener;
  28. privateErrorCallbackmErrorCallback;
定位到Open函数：
public static Camera open(int cameraId) {
return new Camera(cameraId);
}
Open函数是一个静态方法,构造一个Camera对象：
[java] view plain copy
  1. Camera(intcameraId){
  2. mShutterCallback=null;
  3. mRawImageCallback=null;
  4. mJpegCallback=null;
  5. mPreviewCallback=null;
  6. mPostviewCallback=null;
  7. mZoomListener=null;
  9. Looperlooper;
  10. if((looper=Looper.myLooper())!=null){
  11. mEventHandler=newEventHandler(this,looper);
  12. }elseif((looper=Looper.getMainLooper())!=null){
  13. mEventHandler=newEventHandler(this,looper);
  14. }else{
  15. mEventHandler=null;
  16. }
  18. native_setup(newWeakReference<Camera>(this),cameraId);
  19. }

在构造函数中调用native_setup方法，此方法对应于C++代码的android_hardware_Camera_native_setup方法，
实现在android_hardware_Camera.cpp (android4.0\frameworks\base\core\jni)，具体代码如下：
[cpp] view plain copy
  1. staticvoidandroid_hardware_Camera_native_setup(JNIEnv*env,jobjectthiz,
  2. jobjectweak_this,jintcameraId)
  3. {
  4. sp<Camera>camera=Camera::connect(cameraId);
  6. if(camera==NULL){
  7. jniThrowRuntimeException(env,"Failtoconnecttocameraservice");
  8. return;
  9. }
  11. //makesurecamerahardwareisalive
  12. if(camera->getStatus()!=NO_ERROR){
  13. jniThrowRuntimeException(env,"Camerainitializationfailed");
  14. return;
  15. }
  17. jclassclazz=env->GetObjectClass(thiz);
  18. if(clazz==NULL){
  19. jniThrowRuntimeException(env,"Can'tfindandroid/hardware/Camera");
  20. return;
  21. }
  23. //WeuseaweakreferencesotheCameraobjectcanbegarbagecollected.
  24. //Thereferenceisonlyusedasaproxyforcallbacks.
  25. sp<JNICameraContext>context=newJNICameraContext(env,weak_this,clazz,camera);
  26. context->incStrong(thiz);
  27. camera->setListener(context);
  29. //savecontextinopaquefield
  30. env->SetIntField(thiz,fields.context,(int)context.get());
  31. }
在android_hardware_Camera_native_setup方法中调用了Camera对象的connect方法，这个Camera类的声明在Camera.h (android4.0\frameworks\base\include\camera）
定位到connect方法： [cpp] view plain copy
  1. sp<Camera>Camera::connect(intcameraId)
  2. {
  3. LOGV("connect");
  4. sp<Camera>c=newCamera();
  5. constsp<ICameraService>&cs=getCameraService();
  6. if(cs!=0){
  7. c->mCamera=cs->connect(c,cameraId);
  8. }
  9. if(c->mCamera!=0){
  10. c->mCamera->asBinder()->linkToDeath(c);
  11. c->mStatus=NO_ERROR;
  12. }else{
  13. c.clear();
  14. }
  15. returnc;
  16. }
这里以下的代码就比较关键了，涉及到Camera框架的实现机制，Camera系统使用的是Server-Client机制，Service和Client位于不同的进程中，进程间使用Binder机制进行通信，
Service端实际实现相机相关的操作，Client端通过Binder接口调用Service对应的操作。
继续分析代码，上面函数调用getCameraService方法，获得CameraService的引用，ICameraService有两个子类，BnCameraService和BpCameraService，这两个子类同时也
继承了IBinder接口，这两个子类分别实现了Binder通信的两端，Bnxxx实现ICameraService的具体功能，Bpxxx利用Binder的通信功能封装ICameraService方法，具体如下：
[cpp] view plain copy
  1. classICameraService:publicIInterface
  2. {
  3. public:
  4. enum{
  5. GET_NUMBER_OF_CAMERAS=IBinder::FIRST_CALL_TRANSACTION,
  6. GET_CAMERA_INFO,
  7. CONNECT
  8. };
  10. public:
  11. DECLARE_META_INTERFACE(CameraService);
  13. virtualint32_tgetNumberOfCameras()=0;
  14. virtualstatus_tgetCameraInfo(intcameraId,
  15. structCameraInfo*cameraInfo)=0;
  16. virtualsp<ICamera>connect(constsp<ICameraClient>&cameraClient,
  17. intcameraId)=0;
  18. };
  20. //----------------------------------------------------------------------------
  22. classBnCameraService:publicBnInterface<ICameraService>
  23. {
  24. public:
  25. virtualstatus_tonTransact(uint32_tcode,
  26. constParcel&data,
  27. Parcel*reply,
  28. uint32_tflags=0);
  29. };
  31. };//na
[cpp] view plain copy
  1. classBpCameraService:publicBpInterface<ICameraService>
  2. {
  3. public:
  4. BpCameraService(constsp<IBinder>&impl)
  5. :BpInterface<ICameraService>(impl)
  6. {
  7. }
  9. //getnumberofcamerasavailable
  10. virtualint32_tgetNumberOfCameras()
  11. {
  12. Parceldata,reply;
  13. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  14. remote()->transact(BnCameraService::GET_NUMBER_OF_CAMERAS,data,&reply);
  15. returnreply.readInt32();
  16. }
  18. //getinformationaboutacamera
  19. virtualstatus_tgetCameraInfo(intcameraId,
  20. structCameraInfo*cameraInfo){
  21. Parceldata,reply;
  22. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  23. data.writeInt32(cameraId);
  24. remote()->transact(BnCameraService::GET_CAMERA_INFO,data,&reply);
  25. cameraInfo->facing=reply.readInt32();
  26. cameraInfo->orientation=reply.readInt32();
  27. returnreply.readInt32();
  28. }
  30. //connecttocameraservice
  31. virtualsp<ICamera>connect(constsp<ICameraClient>&cameraClient,intcameraId)
  32. {
  33. Parceldata,reply;
  34. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  35. data.writeStrongBinder(cameraClient->asBinder());
  36. data.writeInt32(cameraId);
  37. remote()->transact(BnCameraService::CONNECT,data,&reply);
  38. returninterface_cast<ICamera>(reply.readStrongBinder());
  39. }
  40. };
  42. IMPLEMENT_META_INTERFACE(CameraService,"android.hardware.ICameraService");
  44. //----------------------------------------------------------------------
  46. status_tBnCameraService::onTransact(
  47. uint32_tcode,constParcel&data,Parcel*reply,uint32_tflags)
  48. {
  49. switch(code){
  50. caseGET_NUMBER_OF_CAMERAS:{
  51. CHECK_INTERFACE(ICameraService,data,reply);
  52. reply->writeInt32(getNumberOfCameras());
  53. returnNO_ERROR;
  54. }break;
  55. caseGET_CAMERA_INFO:{
  56. CHECK_INTERFACE(ICameraService,data,reply);
  57. CameraInfocameraInfo;
  58. memset(&cameraInfo,0,sizeof(cameraInfo));
  59. status_tresult=getCameraInfo(data.readInt32(),&cameraInfo);
  60. reply->writeInt32(cameraInfo.facing);
  61. reply->writeInt32(cameraInfo.orientation);
  62. reply->writeInt32(result);
  63. returnNO_ERROR;
  64. }break;
  65. caseCONNECT:{
  66. CHECK_INTERFACE(ICameraService,data,reply);
  67. sp<ICameraClient>cameraClient=interface_cast<ICameraClient>(data.readStrongBinder());
  68. sp<ICamera>camera=connect(cameraClient,data.readInt32());
  69. reply->writeStrongBinder(camera->asBinder());
  70. returnNO_ERROR;
  71. }break;
  72. default:
  73. returnBBinder::onTransact(code,data,reply,flags);
  74. }
  75. }
  77. //----------------------------------------------------------------------------
  79. };//namespaceandroid
下面继续分析sp<Camera> Camera::connect(int cameraId)这个方法，，定位到getCameraService这个方法
[cpp] view plain copy
  1. constsp<ICameraService>&Camera::getCameraService()
  2. {
  3. Mutex::Autolock_l(mLock);
  4. if(mCameraService.get()==0){
  5. sp<IServiceManager>sm=defaultServiceManager();
  6. sp<IBinder>binder;
  7. do{
  8. binder=sm->getService(String16("media.camera"));
  9. if(binder!=0)
  10. break;
  11. LOGW("CameraServicenotpublished,waiting...");
  12. usleep(500000);//0.5s
  13. }while(true);
  14. if(mDeathNotifier==NULL){
  15. mDeathNotifier=newDeathNotifier();
  16. }
  17. binder->linkToDeath(mDeathNotifier);
  18. mCameraService=interface_cast<ICameraService>(binder);
  19. }
  20. LOGE_IF(mCameraService==0,"noCameraService!?");
  21. returnmCameraService;
  22. }
定位到mCameraService = interface_cast<ICameraService>(binder); mCameraService是一个ICamerService类型，更加具体具体一点来讲应该是BpCameraService，
因为在这个类中实现了ICameraService的方法。

总结上面Binder机制，仅仅考虑分析Binder用法，对底层实现不进行深究，基本步骤如下：
1.定义进程间通信的接口比如这里的ICameraService；
2.在BnCameraService和BpCamaraService实现这个接口，这两个接口也分别继承于BnInterface和BpInterface；
3.服务端向ServiceManager注册Binder，客户端向ServiceManager获得Binder；
4.然后就可以实现双向进程间通信了；

通过getCameraService得到ICameraService引用后，调用ICameraService的connect方法获得ICamera引用，

[cpp] view plain copy
  1. <prename="code"class="cpp">c->mCamera=cs->connect(c,cameraId);</pre>进一步跟进connect方法，这里就是BpCameraService类中connect方法的具体实现。<br>
  2. <prename="code"class="cpp">virtualsp<ICamera>connect(constsp<ICameraClient>&cameraClient,intcameraId)
  3. {
  4. Parceldata,reply;
  5. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  6. data.writeStrongBinder(cameraClient->asBinder());
  7. data.writeInt32(cameraId);
  8. remote()->transact(BnCameraService::CONNECT,data,&reply);
  9. returninterface_cast<ICamera>(reply.readStrongBinder());
  10. }</pre>在这里返回的ICamera对象，实际上应该是BpCamera对象，这里使用的是匿名Binder，前面获取CameraService的使用的有名Binder，有名Binder需要借助于ServiceManager获取Binder，而匿名Binder可以通过已经建立后的通信通道（有名Binder）获得。以上是实现Camera框架部分，具体的实现Camera相关的方法是在ICamera相关的接口，下面是给接口的定义：<prename="code"class="cpp">classICamera:publicIInterface
  11. {
  12. public:
  13. DECLARE_META_INTERFACE(Camera);
  15. virtualvoiddisconnect()=0;
  17. //connectnewclientwithexistingcameraremote
  18. virtualstatus_tconnect(constsp<ICameraClient>&client)=0;
  20. //preventotherprocessesfromusingthisICamerainterface
  21. virtualstatus_tlock()=0;
  23. //allowotherprocessestousethisICamerainterface
  24. virtualstatus_tunlock()=0;
  26. //passthebufferedSurfacetothecameraservice
  27. virtualstatus_tsetPreviewDisplay(constsp<Surface>&surface)=0;
  29. //passthebufferedISurfaceTexturetothecameraservice
  30. virtualstatus_tsetPreviewTexture(
  31. constsp<ISurfaceTexture>&surfaceTexture)=0;
  33. //setthepreviewcallbackflagtoaffecthowthereceivedframesfrom
  34. //previewarehandled.
  35. virtualvoidsetPreviewCallbackFlag(intflag)=0;
  37. //startpreviewmode,mustcallsetPreviewDisplayfirst
  38. virtualstatus_tstartPreview()=0;
  40. //stoppreviewmode
  41. virtualvoidstopPreview()=0;
  43. //getpreviewstate
  44. virtualboolpreviewEnabled()=0;
  46. //startrecordingmode
  47. virtualstatus_tstartRecording()=0;
  49. //stoprecordingmode
  50. virtualvoidstopRecording()=0;
  52. //getrecordingstate
  53. virtualboolrecordingEnabled()=0;
  55. //releasearecordingframe
  56. virtualvoidreleaseRecordingFrame(constsp<IMemory>&mem)=0;
  58. //autofocus
  59. virtualstatus_tautoFocus()=0;
  61. //cancelautofocus
  62. virtualstatus_tcancelAutoFocus()=0;
  64. /*
  65. *takeapicture.
  66. *@parammsgTypethemessagetypeanapplicationselectivelyturnon/off
  67. *onaphoto-by-photobasis.Thesupportedmessagetypesare:
  68. *CAMERA_MSG_SHUTTER,CAMERA_MSG_RAW_IMAGE,CAMERA_MSG_COMPRESSED_IMAGE,
  69. *andCAMERA_MSG_POSTVIEW_FRAME.Anyothermessagetypeswillbeignored.
  70. */
  71. virtualstatus_ttakePicture(intmsgType)=0;
  73. //setpreview/captureparameters-key/valuepairs
  74. virtualstatus_tsetParameters(constString8&params)=0;
  76. //getpreview/captureparameters-key/valuepairs
  77. virtualString8getParameters()const=0;
  79. //sendcommandtocameradriver
  80. virtualstatus_tsendCommand(int32_tcmd,int32_targ1,int32_targ2)=0;
  82. //tellthecamerahaltostoremetadataorrealYUVdatainvideobuffers.
  83. virtualstatus_tstoreMetaDataInBuffers(boolenabled)=0;
  84. };</pre><br>
  85. <prename="code"class="cpp"style="background-color:rgb(255,255,255);">ICamera接口有两个子类BnCamera和BpCamera，是Binder通信的两端，BpCamera提供客户端调用接口，BnCamera封装具体的实现，BnCamera也并没有真正实现ICamera相关接口而是在BnCamera子类CameraService::Client中进行实现。而在CameraService::Client类中会继续调用硬件抽象层中相关方法来具体实现Camera功能，
  87. 现在来缕一缕android中Camera各个类如何联系的
  88. 。。。。未完</pre>
  89. <pre></pre>
  90. <pre></pre>
  91. <pre></pre>
  92. <pre></pre>
  93. <pre></pre>

更多相关文章

  1. android listview 圆角的实现方案，模仿Iphone的UITableView
  2. android之播放多媒体文件一（播放音频）
  3. android输入法02：openwnn源码解析01—输入流程
  4. Android(安卓)HIDL学习（2） ---- HelloWorld
  5. 在Android里完美实现基站和WIFI定位
  6. UiAutomator通过ant实现快速调试
  7. Android编程实现连接Wifi(运用Wifi 相关 API)
  8. 浅谈Java中Collections.sort对List排序的两种方法
  9. Python list sort方法的具体使用

随机推荐

  1. android webrtc构建过程
  2. 详解Android(安卓)触摸事件处理和传递过
  3. Android(安卓)String Placeholders
  4. 谁说Android的动画不廉价（三）之共享元素动
  5. usb 配置
  6. 浅谈Android中的线程的通信及Handle机制
  7. android 基础知识整理 1
  8. Android退出程序（三）——Android事件总线
  9. Android: Actions for BroadcastReceiver
  10. Android(安卓)系統存在設計漏洞，釣魚網站