您的位置: 首页  >  文章  >  Android Camera TakePicture過程分析

Android Camera TakePicture過程分析

分类: 文章 • 2025-04-07 19:07:27
Android Camera TakePicture過程分析

接著上一篇文章，繼續講解camera拍照等具體功能實行流程
Camera子系统采用C/S架构,客户端和服务端在两个不同的进程当中,它们使用android中的binder机制进行通信,
本系列文章将从Android Camera应用程序到硬件抽象的实现一步一步对照相机系统进行分析,首先从CameraService初始化过程着手,然后从上层APP打开照相机->进行preview->拍照以及聚焦等功能的实现全面的学习照相机子系统

1、CameraService初始化过程
frameworks\base\media\mediaserver\Main_MediaServer.cpp
CameraService在MediaServer中初始化,代码是MediaServer的main函数,在该函数中初始化照相机服务，已在上一篇文章中講述
CameraService中的instantiate方法用来创建CameraService实例,并进行相应的初始化,这个函数定义在它的父类BinderService中：frameworks/base/include/binder/BinderService.h
相机服务的初始化过程首先是创建CameraService实例,然后将其注册到ServiceManager中,关于它的启动是发生在init.rc中,通过media_server来启动CameraService,具体代码如下：
system/core/rootdir/init.rc
service servicemanager /system/bin/servicemanager
class core
user system
group system
critical
onrestart restart zygote
onrestart restart media
onrestart restart surfaceflinger
onrestart restart drm

service media /system/bin/mediaserver
class main
user media
group audio camera inet net_bt net_bt_admin net_bw_acct drmrpc
ioprio rt 4
在cameraService注册以及启动过程中cameraService自身会执行一些初始化的工作,主要涉及到如下工作
frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. CameraService::CameraService()
  2. :mSoundRef(0),mModule(0)
  3. {
  4. LOGI("CameraService started (pid=%d)",getpid());
  5. gCameraService=this;
  6. }

  8. void CameraService::onFirstRef()
  9. {
  10. BnCameraService::onFirstRef();

  12. if(hw_get_module(CAMERA_HARDWARE_MODULE_ID,
  13. (consthw_module_t**)&mModule)<0){
  14. LOGE("Could not load camera HAL module");
  15. mNumberOfCameras=0;
  16. }
  17. else{
  18. mNumberOfCameras=mModule->get_number_of_cameras();
  19. if(mNumberOfCameras>MAX_CAMERAS){
  20. LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
  21. mNumberOfCameras,MAX_CAMERAS);
  22. mNumberOfCameras=MAX_CAMERAS;
  23. }
  24. for(inti=0;i<mNumberOfCameras;i++){
  25. setCameraFree(i);
  26. }
  27. }
  28. }
在上述初始化代码中,先通过调用HAL硬件抽象层库load camera HAL module,获取支持的摄像头个数并保存到mNumberOfCameras

2、应用程序链接相机服务过程
在camera应用程序启动的时候首先会和CameraService建立连接,camera应用程序代码就不分析了,上一篇文章已經說過，下面这副图是一个简单的流程图
Android Camera TakePicture過程分析
从上面的流程图我们可以看出在请求服务的过程中多出用到了应用框架层的camera类,该类定义在 frameworks/base/core/java/android/hardware/Camera.java文件当中,这一个类正是Camera子系统中APP层和JNI层交换的接口,它对上为应用程序提供了各种操作Camera的方法,向下访问JNI实现它自身的接口Camera类定义如下：

  1. publicclassCamera{
  2. publicstatic Camera open(intcameraId){
  3. return new Camera(cameraId);
  4. }

  6. .................

  8. Camera(intcameraId){
  9. Looper looper;
  10. if((looper=Looper.myLooper())!=null){
  11. mEventHandler=new EventHandler(this,looper);
  12. }elseif((looper=Looper.getMainLooper())!=null){
  13. mEventHandler=new EventHandler(this,looper);
  14. }else{
  15. mEventHandler=null;
  16. }
  17. native_setup(new WeakReference<Camera>(this),cameraId);
  18. }
  19. }
下面就开始从app的takepicture逐步分析camera takepicture整个过程
在app中，takepicture是在capture方法中被调用的：packages/apps/OMAPCamera/src/com/ti/omap4/android/camera/Camera.java（apk）
  1. @Override
  2. publicboolean capture(){
  3. synchronized(mCameraStateLock){
  4. //Ifwe are alreadyinthe middle of taking a snapshotthenignore.
  5. if(mCameraState==SNAPSHOT_IN_PROGRESS||mCameraDevice==null){
  6. returnfalse;
  7. }
  8. mCaptureStartTime=System.currentTimeMillis();
  9. mPostViewPictureCallbackTime=0;
  10. mJpegImageData=null;

  12. //Setrotationandgps data.
  13. Util.setRotationParameter(mParameters,mCameraId,mOrientation);
  14. Locationloc=mLocationManager.getCurrentLocation();
  15. Util.setGpsParameters(mParameters,loc);
  16. if(canSetParameters()){
  17. mCameraDevice.setParameters(mParameters);
  18. }

  20. try{
  21. mCameraDevice.takePicture(mShutterCallback,mRawPictureCallback,
  22. mPostViewPictureCallback,new JpegPictureCallback(loc));
  23. }catch(RuntimeException e){
  24. e.printStackTrace();
  25. returnfalse;
  26. }
  27. mFaceDetectionStarted=false;
  28. setCameraState(SNAPSHOT_IN_PROGRESS);
  29. returntrue;
  30. }
  31. }
这里调用的takePicture是在framework层中定义：frameworks/base/core/java/android/hardware/Camera.java
  1. publicfinal void takePicture(ShutterCallback shutter,PictureCallback raw,
  2. PictureCallback postview,PictureCallback jpeg){
  3. mShutterCallback=shutter;
  4. mRawImageCallback=raw;
  5. mPostviewCallback=postview;
  6. mJpegCallback=jpeg;

  8. //Ifcallbackisnotset,donotsend me callbacks.
  9. intmsgType=0;
  10. if(mShutterCallback!=null){
  11. msgType|=CAMERA_MSG_SHUTTER;
  12. }
  13. if(mRawImageCallback!=null){
  14. msgType|=CAMERA_MSG_RAW_IMAGE;
  15. }
  16. if(mPostviewCallback!=null){
  17. msgType|=CAMERA_MSG_POSTVIEW_FRAME;
  18. }
  19. if(mJpegCallback!=null){
  20. msgType|=CAMERA_MSG_COMPRESSED_IMAGE;
  21. }

  23. native_takePicture(msgType);
  24. }
在这里设置callback函数，并调用通过JNI调用takepicture方法：frameworks/base/core/jni/android_hardware_Camera.cpp
  1. static void android_hardware_Camera_takePicture(JNIEnv*env,jobject thiz,intmsgType)
  2. {
  3. LOGV("takePicture");
  4. JNICameraContext*context;
  5. sp<Camera>camera=get_native_camera(env,thiz,&context);
  6. if(camera==0)return;

  8. /*
  9. *When CAMERA_MSG_RAW_IMAGEisrequested,ifthe raw image callback
  10. *bufferisavailable,CAMERA_MSG_RAW_IMAGEisenabledtogetthe
  11. *notification _and_ the data;otherwise,CAMERA_MSG_RAW_IMAGE_NOTIFY
  12. *isenabledtoreceive the callback notification but no data.
  13. *
  14. *Note that CAMERA_MSG_RAW_IMAGE_NOTIFYisnotexposedtothe
  15. *Java application.
  16. */
  17. if(msgType&CAMERA_MSG_RAW_IMAGE){
  18. LOGV("Enable raw image callback buffer");
  19. if(!context->isRawImageCallbackBufferAvailable()){
  20. LOGV("Enable raw image notification, since no callback buffer exists");
  21. msgType&=~CAMERA_MSG_RAW_IMAGE;
  22. msgType|=CAMERA_MSG_RAW_IMAGE_NOTIFY;
  23. }
  24. }

  26. if(camera->takePicture(msgType)!=NO_ERROR){
  27. jniThrowRuntimeException(env,"takePicture failed");
  28. return;
  29. }
  30. }
这里调用camera 的takepicture，即camera client 的takepicture方法：frameworks/base/libs/camera/Camera.cpp
  1. status_t Camera::takePicture(intmsgType,constString8&params)
  2. {
  3. LOGV("takePicture: 0x%x",msgType);
  4. sp<ICamera>c=mCamera;
  5. if(c==0)return NO_INIT;
  6. return c->takePicture(msgType,params);
  7. }
这里client 端的takepicture又调用到cameraserver端的takepicture：frameworks/base/services/camera/libcameraservice/CameraService.cpp

  1. //take a picture-imageisreturnedincallback
  2. #ifdef OMAP_ENHANCEMENT_CPCAM
  3. status_t CameraService::Client::takePicture(intmsgType,constString8&params){
  4. #else
  5. status_t CameraService::Client::takePicture(intmsgType){
  6. #endif
  7. LOG1("takePicture (pid %d): 0x%x",getCallingPid(),msgType);

  9. Mutex::Autolock lock(mLock);
  10. status_t result=checkPidAndHardware();
  11. if(result!=NO_ERROR)return result;

  13. if((msgType&CAMERA_MSG_RAW_IMAGE)&&
  14. (msgType&CAMERA_MSG_RAW_IMAGE_NOTIFY)){
  15. LOGE("CAMERA_MSG_RAW_IMAGE and CAMERA_MSG_RAW_IMAGE_NOTIFY"
  16. " cannot be both enabled");
  17. return BAD_VALUE;
  18. }

  20. //We only accept picture related message types
  21. //andignore other types of messagesfortakePicture().
  22. intpicMsgType=msgType
  23. &(CAMERA_MSG_SHUTTER|
  24. CAMERA_MSG_POSTVIEW_FRAME|
  25. CAMERA_MSG_RAW_IMAGE|
  26. #ifdef OMAP_ENHANCEMENT
  27. CAMERA_MSG_RAW_BURST|
  28. #endif
  29. CAMERA_MSG_RAW_IMAGE_NOTIFY|
  30. CAMERA_MSG_COMPRESSED_IMAGE);
  31. #ifdef OMAP_ENHANCEMENT
  32. picMsgType|=CAMERA_MSG_COMPRESSED_BURST_IMAGE;
  33. #endif

  35. enableMsgType(picMsgType);

  37. #ifdef OMAP_ENHANCEMENT
  38. //make sure the other capture messages are disabled
  39. picMsgType=~picMsgType&
  40. (CAMERA_MSG_SHUTTER|
  41. CAMERA_MSG_POSTVIEW_FRAME|
  42. CAMERA_MSG_RAW_IMAGE|
  43. CAMERA_MSG_RAW_BURST|
  44. CAMERA_MSG_RAW_IMAGE_NOTIFY|
  45. CAMERA_MSG_COMPRESSED_IMAGE|
  46. CAMERA_MSG_COMPRESSED_BURST_IMAGE);
  47. disableMsgType(picMsgType);
  48. #endif

  50. #ifdef OMAP_ENHANCEMENT_CPCAM
  51. return mHardware->takePicture(params);
  52. #else
  53. return mHardware->takePicture();
  54. #endif
  55. }
一些初始化之后，最终server端的takepicture方法会调用HAL层（硬件接口层）的takepicture方法：frameworks/base/services/camera/libcameraservice/CameraHardwareInterface.h
  1. /**
  2. *Take a picture.
  3. */
  4. #ifdef OMAP_ENHANCEMENT_CPCAM
  5. status_t takePicture(constShotParameters&params)
  6. {
  7. LOGV("%s(%s)",__FUNCTION__,mName.string());
  8. if(mDevice->ops->take_picture)
  9. return mDevice->ops->take_picture(mDevice,
  10. params.flatten().string());
  11. return INVALID_OPERATION;
  12. }
  13. #else
  14. status_t takePicture()
  15. {
  16. LOGV("%s(%s)",__FUNCTION__,mName.string());
  17. if(mDevice->ops->take_picture)
  18. return mDevice->ops->take_picture(mDevice);//从这里开始通过V4L2子系统调用到kerner driver的设备，以后针对这个部分做详细学习
  19. return INVALID_OPERATION;
  20. }
  21. #endif
下面的重点是分析数据回调过程，这个过程是camera的最重点，在我看来也是最难点理解的地方，要多花点时间，努把力了，现在就开始
首先还是必须先追溯到Camera客户端与服务端连接的时候，由我的上一遍初始化的文章知道，Camera客户端与服务端连接的时候，首先调用的是client端的connect方法，
client的connect方法首先getservice，然后调用server端的connect方法，为了方便理解我再次把这部分代码贴出：
server的connect（）函数定义在以下路径:frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. sp<ICamera>CameraService::connect(
  2. constsp<ICameraClient>&cameraClient,intcameraId){
  3. intcallingPid=getCallingPid();
  4. sp<CameraHardwareInterface>hardware=NULL;

  6. LOG1("CameraService::connect E (pid %d, id %d)",callingPid,cameraId);

  8. if(!mModule){
  9. LOGE("Camera HAL module not loaded");
  10. returnNULL;
  11. }

  13. sp<Client>client;
  14. if(cameraId<0||cameraId>=mNumberOfCameras){
  15. LOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
  16. callingPid,cameraId);
  17. returnNULL;
  18. }

  20. char value[PROPERTY_VALUE_MAX];
  21. property_get("sys.secpolicy.camera.disabled",value,"0");
  22. if(strcmp(value,"1")==0){
  23. //Cameraisdisabled by DevicePolicyManager.
  24. LOGI("Camera is disabled. connect X (pid %d) rejected",callingPid);
  25. returnNULL;
  26. }

  28. Mutex::Autolock lock(mServiceLock);
  29. if(mClient[cameraId]!=0){
  30. client=mClient[cameraId].promote();
  31. if(client!=0){
  32. if(cameraClient->asBinder()==client->getCameraClient()->asBinder()){
  33. LOG1("CameraService::connect X (pid %d) (the same client)",
  34. callingPid);
  35. return client;
  36. }else{
  37. LOGW("CameraService::connect X (pid %d) rejected (existing client).",
  38. callingPid);
  39. returnNULL;
  40. }
  41. }
  42. mClient[cameraId].clear();
  43. }

  45. if(mBusy[cameraId]){
  46. LOGW("CameraService::connect X (pid %d) rejected"
  47. " (camera %d is still busy).",callingPid,cameraId);
  48. returnNULL;
  49. }

  51. struct camera_info info;
  52. if(mModule->get_camera_info(cameraId,&info)!=OK){
  53. LOGE("Invalid camera id %d",cameraId);
  54. returnNULL;
  55. }

  57. char camera_device_name[10];
  58. snprintf(camera_device_name,sizeof(camera_device_name),"%d",cameraId);

  60. hardware=new CameraHardwareInterface(camera_device_name);
  61. if(hardware->initialize(&mModule->common)!=OK){
  62. hardware.clear();
  63. returnNULL;
  64. }

  66. client=new Client(this,cameraClient,hardware,cameraId,info.facing,callingPid);
  67. mClient[cameraId]=client;
  68. LOG1("CameraService::connect X");
  69. return client;
  70. }
最重要的地方在上面标注的绿色部分，这里在connect成功之后会new一个client，这个Client是CamereService类的内部类，
这个时候便会调用client这个内部类的client构造函数，而我们的回调函数也正是在这个时候被设置，看看代码：

  1. CameraService::Client::Client(constsp<CameraService>&cameraService,
  2. constsp<ICameraClient>&cameraClient,
  3. constsp<CameraHardwareInterface>&hardware,
  4. intcameraId,intcameraFacing,intclientPid){
  5. intcallingPid=getCallingPid();
  6. LOG1("Client::Client E (pid %d)",callingPid);

  8. mCameraService=cameraService;
  9. mCameraClient=cameraClient;
  10. mHardware=hardware;
  11. mCameraId=cameraId;
  12. mCameraFacing=cameraFacing;
  13. mClientPid=clientPid;
  14. mMsgEnabled=0;
  15. mSurface=0;
  16. mPreviewWindow=0;
  17. #ifdef OMAP_ENHANCEMENT_CPCAM
  18. mTapin=0;
  19. mTapinClient=0;
  20. mTapout=0;
  21. mTapoutClient=0;
  22. #endif
  23. mHardware->setCallbacks(notifyCallback,
  24. dataCallback,
  25. dataCallbackTimestamp,
  26. (void*)cameraId);

  28. //Enable zoom,error,focus,andmetadata messages by default
  29. enableMsgType(CAMERA_MSG_ERROR|CAMERA_MSG_ZOOM|CAMERA_MSG_FOCUS|
  30. CAMERA_MSG_PREVIEW_METADATA);

  32. //Callbackisdisabled by default
  33. mPreviewCallbackFlag=CAMERA_FRAME_CALLBACK_FLAG_NOOP;
  34. mOrientation=getOrientation(0,mCameraFacing==CAMERA_FACING_FRONT);
  35. mPlayShutterSound=true;
  36. cameraService->setCameraBusy(cameraId);
  37. cameraService->loadSound();
  38. LOG1("Client::Client X (pid %d)",callingPid);
  39. }
上面就对camera设置了notifyCallback、dataCallback、dataCallbackTimestamp三个回调函数，用于返回底层数据用于处理，看下它的处理方法：
这里先针对其中的dataCallback回调方法做介绍，其他的回调方法以此类推，所以我们就先看一下dataCallback方法中都做了些什么事情：
这里的回调函数是camera server层的回调函数：frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. void CameraService::Client::dataCallback(int32_t msgType,
  2. constsp<IMemory>&dataPtr,camera_frame_metadata_t*metadata,void*user){
  3. LOG2("dataCallback(%d)",msgType);

  5. sp<Client>client=getClientFromCookie(user);
  6. if(client==0)return;
  7. if(!client->lockIfMessageWanted(msgType))return;

  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. }

  15. switch(msgType&~CAMERA_MSG_PREVIEW_METADATA){
  16. caseCAMERA_MSG_PREVIEW_FRAME:
  17. client->handlePreviewData(msgType,dataPtr,metadata);
  18. break;
  19. caseCAMERA_MSG_POSTVIEW_FRAME:
  20. client->handlePostview(dataPtr);
  21. break;
  22. caseCAMERA_MSG_RAW_IMAGE:
  23. client->handleRawPicture(dataPtr);
  24. break;
  25. caseCAMERA_MSG_COMPRESSED_IMAGE:
  26. client->handleCompressedPicture(dataPtr);
  27. break;
  28. #ifdef OMAP_ENHANCEMENT
  29. caseCAMERA_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过程需要大量数据传输，而且容易大家理解，这里就针对preview数据回调过程进行分析：
  1. //preview callback-frame buffer update
  2. void CameraService::Client::handlePreviewData(int32_t msgType,
  3. constsp<IMemory>&mem,
  4. camera_frame_metadata_t*metadata){
  5. ssize_t offset;
  6. size_t size;
  7. sp<IMemoryHeap>heap=mem->getMemory(&offset,&size);

  9. //local copy of the callback flags
  10. intflags=mPreviewCallbackFlag;

  12. //iscallback enabled?
  13. if(!(flags&CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK)){
  14. //Ifthe enable bitisoff,the copy-outandone-shot bits are ignored
  15. LOG2("frame callback is disabled");
  16. mLock.unlock();
  17. return;
  18. }

  20. //hold a strong pointertothe client
  21. sp<ICameraClient>c=mCameraClient;

  23. //clear callback flagsifno clientorone-shot mode
  24. if(c==0||(mPreviewCallbackFlag&CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK)){
  25. LOG2("Disable preview callback");
  26. mPreviewCallbackFlag&=~(CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK|
  27. CAMERA_FRAME_CALLBACK_FLAG_COPY_OUT_MASK|
  28. CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK);
  29. disableMsgType(CAMERA_MSG_PREVIEW_FRAME);
  30. }

  32. if(c!=0){
  33. //Isthe received frame copied outornot?
  34. if(flags&CAMERA_FRAME_CALLBACK_FLAG_COPY_OUT_MASK){
  35. LOG2("frame is copied");
  36. copyFrameAndPostCopiedFrame(msgType,c,heap,offset,size,metadata);
  37. }else{
  38. LOG2("frame is forwarded");
  39. mLock.unlock();
  40. c->dataCallback(msgType,mem,metadata);
  41. }
  42. }else{
  43. mLock.unlock();
  44. }
  45. }
这里有两个方向
copyFrameAndPostCopiedFrame这个函数执行两个buff区preview数据的投递，通过它的具体实现过程，可以知道最终他也要调用dataCallback方法继续调用客户端client的回调函数
所以这里直接分析copyFrameAndPostCopiedFrame：
  1. void CameraService::Client::copyFrameAndPostCopiedFrame(
  2. int32_t msgType,constsp<ICameraClient>&client,
  3. constsp<IMemoryHeap>&heap,size_t offset,size_t size,
  4. camera_frame_metadata_t*metadata){
  5. LOG2("copyFrameAndPostCopiedFrame");
  6. //Itisnecessarytocopy out of pmem before sending thisto
  7. //the callback.Forefficiency,reuse the same MemoryHeapBase
  8. //provided it's big enough.Don't allocate the memoryor
  9. //perform the copyifthere's no callback.
  10. //hold the preview lockwhilewe grab a referencetothe preview buffer
  11. sp<MemoryHeapBase>previewBuffer;

  13. if(mPreviewBuffer==0){
  14. mPreviewBuffer=new MemoryHeapBase(size,0,NULL);
  15. }elseif(size>mPreviewBuffer->virtualSize()){
  16. mPreviewBuffer.clear();
  17. mPreviewBuffer=new MemoryHeapBase(size,0,NULL);
  18. }
  19. if(mPreviewBuffer==0){
  20. LOGE("failed to allocate space for preview buffer");
  21. mLock.unlock();
  22. return;
  23. }
  24. previewBuffer=mPreviewBuffer;

  26. memcpy(previewBuffer->base(),(uint8_t*)heap->base()+offset,size);

  28. sp<MemoryBase>frame=new MemoryBase(previewBuffer,0,size);
  29. if(frame==0){
  30. LOGE("failed to allocate space for frame callback");
  31. mLock.unlock();
  32. return;
  33. }

  35. mLock.unlock();
  36. client->dataCallback(msgType,frame,metadata);
  37. }
从这里开始，回调函数进入到camera client的回调函数：frameworks/base/libs/camera/Camera.cpp
  1. //callback from camera service when frameorimageisready
  2. void Camera::dataCallback(int32_t msgType,constsp<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. //connecttocamera 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);

  7. if(camera==NULL){
  8. jniThrowRuntimeException(env,"Fail to connect to camera service");
  9. return;
  10. }

  12. //make sure camera hardwareisalive
  13. if(camera->getStatus()!=NO_ERROR){
  14. jniThrowRuntimeException(env,"Camera initialization failed");
  15. return;
  16. }

  18. jclass clazz=env->GetObjectClass(thiz);
  19. if(clazz==NULL){
  20. jniThrowRuntimeException(env,"Can't find android/hardware/Camera");
  21. return;
  22. }

  24. //We use a weak reference so the Camera object can be garbage collected.
  25. //The referenceisonly used as a proxyforcallbacks.
  26. sp<JNICameraContext>context=new JNICameraContext(env,weak_this,clazz,camera);
  27. context->incStrong(thiz);
  28. camera->setListener(context);

  30. //save contextinopaque field
  31. env->SetIntField(thiz,fields.context,(int)context.get());
  32. }
由上面可以看出JNICameraContext是个监听类，同时set这个监听类，这个类的定义在：frameworks/base/core/jni/android_hardware_Camera.cpp
  1. //provides persistent contextforcalls from native codetoJava
  2. classJNICameraContext:publicCameraListener
  3. {
  4. public:
  5. JNICameraContext(JNIEnv*env,jobject weak_this,jclass clazz,constsp<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,constsp<IMemory>&dataPtr,
  9. camera_frame_metadata_t*metadata);
  10. virtual void postDataTimestamp(nsecs_t timestamp,int32_t msgType,constsp<IMemory>&dataPtr);
  11. void postMetadata(JNIEnv*env,int32_t msgType,camera_frame_metadata_t*metadata);
  12. void addCallbackBuffer(JNIEnv*env,jbyteArray cbb,intmsgType);
  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();

  18. private:
  19. void copyAndPost(JNIEnv*env,constsp<IMemory>&dataPtr,intmsgType);
  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);

  24. jobject mCameraJObjectWeak;//weak referencetojava object
  25. jclass mCameraJClass;//strong referencetojavaclass
  26. sp<Camera>mCamera;//strong referencetonative object
  27. jclass mFaceClass;//strong referencetoFaceclass
  28. jclass mRectClass;//strong referencetoRectclass
  29. Mutex mLock;

  31. /*
  32. *Global reference application-managed raw image buffer queue.
  33. *
  34. *Manual-only modeissupportedforraw image callbacks,whichis
  35. *setwhenever method addCallbackBuffer()with msgType=
  36. *CAMERA_MSG_RAW_IMAGEiscalled;otherwise,nullisreturned
  37. *with raw image callbacks.
  38. */
  39. Vector<jbyteArray>mRawImageCallbackBuffers;

  41. /*
  42. *Application-managed preview buffer queueandthe flags
  43. *associated with the usage of the preview buffer callback.
  44. */
  45. Vector<jbyteArray>mCallbackBuffers;//Global reference application managed byte[]
  46. bool mManualBufferMode;//Whethertouse application managed buffers.
  47. bool mManualCameraCallbackSet;//Whether the callback has beenset,usedto
  48. //reduce unnecessary callstosetthe callback.
  49. };
标注部分是我们在上面用到的postData，我们看一看postData的实现过程：
  1. void JNICameraContext::postData(int32_t msgType,constsp<IMemory>&dataPtr,
  2. camera_frame_metadata_t*metadata)
  3. {
  4. //VM pointer will beNULLifobjectisreleased
  5. Mutex::Autolock _l(mLock);
  6. JNIEnv*env=AndroidRuntime::getJNIEnv();
  7. if(mCameraJObjectWeak==NULL){
  8. LOGW("callback on dead camera object");
  9. return;
  10. }

  12. int32_t dataMsgType=msgType&~CAMERA_MSG_PREVIEW_METADATA;

  14. //return data basedoncallback type
  15. switch(dataMsgType){
  16. caseCAMERA_MSG_VIDEO_FRAME:
  17. //should never happen
  18. break;

  20. //Forbackward-compatibility purpose,ifthereisno callback
  21. //bufferforraw image,the callback returnsnull.
  22. caseCAMERA_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;

  32. //Thereisno data.
  33. case0:
  34. break;

  36. default:
  37. LOGV("dataCallback(%d, %p)",dataMsgType,dataPtr.get());
  38. copyAndPost(env,dataPtr,dataMsgType);
  39. break;
  40. }

  42. //post frame metadatatoJava
  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,constsp<IMemory>&dataPtr,intmsgType)
  2. {
  3. jbyteArray obj=NULL;

  5. //allocate Java bytearrayandcopy 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();

  13. if(heapBase!=NULL){
  14. constjbyte*data=reinterpret_cast<constjbyte*>(heapBase+offset);

  16. if(msgType==CAMERA_MSG_RAW_IMAGE){
  17. obj=getCallbackBuffer(env,&mRawImageCallbackBuffers,size);
  18. }elseif(msgType==CAMERA_MSG_PREVIEW_FRAME&&mManualBufferMode){
  19. obj=getCallbackBuffer(env,&mCallbackBuffers,size);

  21. if(mCallbackBuffers.isEmpty()){
  22. LOGV("Out of buffers, clearing callback!");
  23. mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
  24. mManualCameraCallbackSet=false;

  26. if(obj==NULL){
  27. return;
  28. }
  29. }
  30. }else{
  31. LOGV("Allocating callback buffer");
  32. obj=env->NewByteArray(size);
  33. }

  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. }

  46. //post image datatoJava
  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. privatestatic void postEventFromNative(Object camera_ref,
  2. intwhat,intarg1,intarg2,Object obj)
  3. {
  4. Camera c=(Camera)((WeakReference)camera_ref).get();
  5. if(c==null)
  6. return;

  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. privateclassEventHandler extends Handler
  2. {
  3. privateCamera mCamera;

  5. publicEventHandler(Camera c,Looper looper){
  6. super(looper);
  7. mCamera=c;
  8. }

  10. @Override
  11. publicvoid handleMessage(Message msg){
  12. switch(msg.what){
  13. caseCAMERA_MSG_SHUTTER:
  14. if(mShutterCallback!=null){
  15. mShutterCallback.onShutter();
  16. }
  17. return;

  19. caseCAMERA_MSG_RAW_IMAGE:
  20. if(mRawImageCallback!=null){
  21. mRawImageCallback.onPictureTaken((byte[])msg.obj,mCamera);
  22. }
  23. return;

  25. caseCAMERA_MSG_COMPRESSED_IMAGE:
  26. if(mJpegCallback!=null){
  27. mJpegCallback.onPictureTaken((byte[])msg.obj,mCamera);
  28. }
  29. return;

  31. caseCAMERA_MSG_PREVIEW_FRAME:
  32. if(mPreviewCallback!=null){
  33. PreviewCallback cb=mPreviewCallback;
  34. if(mOneShot){
  35. //Clear the callback variable before the callback
  36. //incasethe app calls setPreviewCallback from
  37. //the callbackfunction
  38. mPreviewCallback=null;
  39. }elseif(!mWithBuffer){
  40. //We're faking the camera preview modetoprevent
  41. //the app from being flooded with preview frames.
  42. //Settooneshot mode again.
  43. setHasPreviewCallback(true,false);
  44. }
  45. cb.onPreviewFrame((byte[])msg.obj,mCamera);
  46. }
  47. return;

  49. caseCAMERA_MSG_POSTVIEW_FRAME:
  50. if(mPostviewCallback!=null){
  51. mPostviewCallback.onPictureTaken((byte[])msg.obj,mCamera);
  52. }
  53. return;

  55. caseCAMERA_MSG_FOCUS:
  56. if(mAutoFocusCallback!=null){
  57. mAutoFocusCallback.onAutoFocus(msg.arg1==0?false:true,mCamera);
  58. }
  59. return;

  61. caseCAMERA_MSG_ZOOM:
  62. if(mZoomListener!=null){
  63. mZoomListener.onZoomChange(msg.arg1,msg.arg2!=0,mCamera);
  64. }
  65. return;

  67. caseCAMERA_MSG_PREVIEW_METADATA:
  68. if(mFaceListener!=null){
  69. mFaceListener.onFaceDetection((Face[])msg.obj,mCamera);
  70. }
  71. return;

  73. caseCAMERA_MSG_ERROR:
  74. Log.e(TAG,"Error "+msg.arg1);
  75. if(mErrorCallback!=null){
  76. mErrorCallback.onError(msg.arg1,mCamera);
  77. }
  78. return;

  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 usedtodeliver 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. publicinterface PreviewCallback
  11. {
  12. /**
  13. *Called as preview frames are displayed.This callbackisinvoked
  14. *onthe event thread{@link#open(int)}was called from.
  15. *
  16. *@param data the contents of the preview frameinthe format defined
  17. *by{@linkandroid.graphics.ImageFormat},which can be queried
  18. *with{@linkandroid.hardware.Camera.Parameters#getPreviewFormat()}.
  19. *If{@linkandroid.hardware.Camera.Parameters#setPreviewFormat(int)}
  20. *isnever 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层完成的。
takePicture（）处理过程跟preview差不多，只是增加了回调函数返回时候存储图像的动作，这里分析一下takepicture的处理过程：
  1. caseCAMERA_MSG_COMPRESSED_IMAGE:
  2. if(mJpegCallback!=null){
  3. mJpegCallback.onPictureTaken((byte[])msg.obj,mCamera);
  4. }
  5. return;
mJpegCallback的定义
private PictureCallback mJpegCallback;
走到这里我们又不得不回头看看最起初在调用takepicture的时候是怎么调用的
  1. try{
  2. mCameraDevice.takePicture(mShutterCallback,mRawPictureCallback,
  3. mPostViewPictureCallback,new JpegPictureCallback(loc));
  4. }catch(RuntimeException e){
  5. e.printStackTrace();
  6. returnfalse;
  7. }
这里大家看到了标准部分就是要使用的mJpegCallback，但是这个callback是JpegPictureCallback类，我们定义的mJpegCallback确是PictureCallback类，不是同一个类
所以这个还是必须得说清楚一点，看看JpegPictureCallback类的定义吧
  1. privatefinalclassJpegPictureCallback implements PictureCallback{
  2. LocationmLocation;

  4. publicJpegPictureCallback(Locationloc){
  5. mLocation=loc;
  6. }

  8. publicvoid onPictureTaken(
  9. final byte[]jpegData,final android.hardware.Camera camera){
  10. if(mPausing){
  11. if(mBurstImages>0){
  12. resetBurst();
  13. mBurstImages=0;
  14. mHandler.sendEmptyMessageDelayed(RELEASE_CAMERA,
  15. CAMERA_RELEASE_DELAY);
  16. }
  17. return;
  18. }

  20. FocusManager.TempBracketingStates tempState=mFocusManager.getTempBracketingState();
  21. mJpegPictureCallbackTime=System.currentTimeMillis();
  22. //Ifpostview callback has arrived,the captured imageisdisplayed
  23. //inpostview callback.Ifnot,the captured imageisdisplayedin
  24. //raw picture callback.
  25. if(mPostViewPictureCallbackTime!=0){
  26. mShutterToPictureDisplayedTime=
  27. mPostViewPictureCallbackTime-mShutterCallbackTime;
  28. mPictureDisplayedToJpegCallbackTime=
  29. mJpegPictureCallbackTime-mPostViewPictureCallbackTime;
  30. }else{
  31. mShutterToPictureDisplayedTime=
  32. mRawPictureCallbackTime-mShutterCallbackTime;
  33. mPictureDisplayedToJpegCallbackTime=
  34. mJpegPictureCallbackTime-mRawPictureCallbackTime;
  35. }
  36. Log.v(TAG,"mPictureDisplayedToJpegCallbackTime = "
  37. +mPictureDisplayedToJpegCallbackTime+"ms");

  39. if(!mIsImageCaptureIntent){
  40. enableCameraControls(true);

  42. if((tempState!=FocusManager.TempBracketingStates.RUNNING)&&
  43. !mCaptureMode.equals(mExposureBracketing)&&
  44. !mCaptureMode.equals(mZoomBracketing)&&
  45. !mBurstRunning==true){
  46. //We wanttoshow the taken pictureforawhile,so we wait
  47. //forat least 0.5secondbefore restarting the preview.
  48. long delay=500-mPictureDisplayedToJpegCallbackTime;
  49. if(delay<0){
  50. startPreview(true);
  51. startFaceDetection();
  52. }else{
  53. mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW,delay);
  54. }
  55. }

  57. }

  59. if(!mIsImageCaptureIntent){
  60. Size s=mParameters.getPictureSize();
  61. mImageSaver.addImage(jpegData,mLocation,s.width,s.height);
  62. }else{
  63. mJpegImageData=jpegData;
  64. if(!mQuickCapture){
  65. showPostCaptureAlert();
  66. }else{
  67. doAttach();
  68. }
  69. }

  71. //Check thisinadvance ofeachshot so we don't addtoshutter
  72. //latency.It'struethat someoneelsecould writetothe SD cardin
  73. //the meantimeandfill it,but that could have happened between the
  74. //shutter pressandsaving the JPEG too.
  75. checkStorage();

  77. if(!mHandler.hasMessages(RESTART_PREVIEW)){
  78. longnow=System.currentTimeMillis();
  79. mJpegCallbackFinishTime=now-mJpegPictureCallbackTime;
  80. Log.v(TAG,"mJpegCallbackFinishTime = "
  81. +mJpegCallbackFinishTime+"ms");
  82. mJpegPictureCallbackTime=0;
  83. }

  85. if(mCaptureMode.equals(mExposureBracketing)){
  86. mBurstImages--;
  87. if(mBurstImages==0){
  88. mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW,0);
  89. }
  90. }

  92. //reset burstincaseof exposure bracketing
  93. if(mCaptureMode.equals(mExposureBracketing)&&mBurstImages==0){
  94. mBurstImages=EXPOSURE_BRACKETING_COUNT;
  95. mParameters.set(PARM_BURST,mBurstImages);
  96. mCameraDevice.setParameters(mParameters);
  97. }

  99. if(mCaptureMode.equals(mZoomBracketing)){
  100. mBurstImages--;
  101. if(mBurstImages==0){
  102. mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW,0);
  103. }
  104. }

  106. //reset burstincaseof zoom bracketing
  107. if(mCaptureMode.equals(mZoomBracketing)&&mBurstImages==0){
  108. mBurstImages=ZOOM_BRACKETING_COUNT;
  109. mParameters.set(PARM_BURST,mBurstImages);
  110. mCameraDevice.setParameters(mParameters);
  111. }

  113. if(tempState==FocusManager.TempBracketingStates.RUNNING){
  114. mBurstImages--;
  115. if(mBurstImages==0){
  116. mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW,0);
  117. mTempBracketingEnabled=true;
  118. stopTemporalBracketing();
  119. }
  120. }

  122. if(mBurstRunning){
  123. mBurstImages--;
  124. if(mBurstImages==0){
  125. resetBurst();
  126. mBurstRunning=false;
  127. mHandler.sendEmptyMessageDelayed(RESTART_PREVIEW,0);
  128. }
  129. }
  130. }
  131. }
原来他们是父子类之间的关系，那么自然父类可以可以转换为子类的形式，但是子类就不能向父类转换了，这个不懂就没办法了，面向对象的知识
而且这里子类重新实现了父类的方法onPictureTaken
这里这个函数不就是handle里面调用的函数了嘛，可以看到上面onPictureTaken的实现过程，其实与preview最大的不同就是我上面标注的部分，
takepicture最终将图片保存下来了
好了，takepicture的过程就说到这里了，下一步要进底层了，HAL和driver之间的那些事，driver做的那些事

相关推荐