Android Camera 系统框架分析

发布时间:2013-9-16 16:28    发布者:reggae
关键词: android
一、在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系统最上层,应用层的实现。
(PS:^_^不错的Android学习交流群314230976,验证:eec,有兴趣的话可以加入进来一起讨论)
下面是Camera类部分代码
  1. public class Camera extends ActivityBase implements FocusManager.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这个函数中:

  1. @Override
  2. protected void doOnResume() {
  3. if (mOpenCameraFail || mCameraDisabled) return;

  4. mPausing = false;

  5. mJpegPictureCallbackTime = 0;
  6. mZoomValue = 0;

  7. // Start the preview if it is not started.
  8. if (mCameraState == PREVIEW_STOPPED) {
  9. try {
  10. mCameraDevice = Util.openCamera(this, mCameraId);
  11. initializeCapabilities();
  12. resetExposureCompensation();
  13. startPreview();
  14. if (mFirstTimeInitialized) startFaceDetection();
  15. } catch (CameraHardwareException e) {
  16. Util.showErrorAndFinish(this, R.string.cannot_connect_camera);
  17. return;
  18. } catch (CameraDisabledException e) {
  19. Util.showErrorAndFinish(this, R.string.camera_disabled);
  20. return;
  21. }
  22. }

  23. if (mSurfaceHolder != null) {
  24. // If first time initialization is not finished, put it in the
  25. // message queue.
  26. if (!mFirstTimeInitialized) {
  27. mHandler.sendEmptyMessage(FIRST_TIME_INIT);
  28. } else {
  29. initializeSecondTime();
  30. }
  31. }
  32. keepScreenOnAwhile();

  33. if (mCameraState == IDLE) {
  34. mOnResumeTime = SystemClock.uptimeMillis();
  35. mHandler.sendEmptyMessageDelayed(CHECK_DISPLAY_ROTATION, 100);
  36. }
  37. }
复制代码
在这个函数中看到通过这个函数获得Camera底层对象
mCameraDevice = Util.openCamera(this, mCameraId),这里使用Util这个类,这个类的实现在
Util.java (android4.0\packages\apps\camera\src\com\android\camera)中,找到OpenCamera这个函数实现:

  1. public static android.hardware.Camera openCamera(Activity activity, int cameraId)
  2. throws CameraHardwareException, CameraDisabledException {
  3. // Check if device policy has disabled the camera.
  4. DevicePolicyManager dpm = (DevicePolicyManager) activity.getSystemService(
  5. Context.DEVICE_POLICY_SERVICE);
  6. if (dpm.getCameraDisabled(null)) {
  7. throw new CameraDisabledException();
  8. }

  9. try {
  10. return CameraHolder.instance().open(cameraId);
  11. } catch (CameraHardwareException e) {
  12. // In eng build, we throw the exception so that test tool
  13. // can detect it and report it
  14. if ("eng".equals(Build.TYPE)) {
  15. throw new RuntimeException("openCamera failed", e);
  16. } else {
  17. throw e;
  18. }
  19. }
  20. }
复制代码
从这个函数可以看出,android系统中对下层Camera管理,是通过一个单例模式CameraHolder来管理的,
定位到这个类的实现CameraHolder.java (android4.0\packages\apps\camera\src\com\android\camera)通过调用open函数获取一个Camera硬件设备对象,
因为Camera设备是独享设备,不能同时被两个进程占用,而整个android系统是一个多进程环境,因此需要加入一些进程间互斥同步的方法。
定位到这个类的open函数:

  1. public synchronized android.hardware.Camera open(int cameraId)
  2. throws CameraHardwareException {
  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, "open camera " + cameraId);
  12. mCameraDevice = android.hardware.Camera.open(cameraId);
  13. mCameraId = cameraId;
  14. } catch (RuntimeException e) {
  15. Log.e(TAG, "fail to connect Camera", e);
  16. throw new CameraHardwareException(e);
  17. }
  18. mParameters = mCameraDevice.getParameters();
  19. } else {
  20. try {
  21. mCameraDevice.reconnect();
  22. } catch (IOException e) {
  23. Log.e(TAG, "reconnect failed.");
  24. throw new CameraHardwareException(e);
  25. }
  26. mCameraDevice.setParameters(mParameters);
  27. }
  28. ++mUsers;
  29. mHandler.removeMessages(RELEASE_CAMERA);
  30. mKeepBeforeTime = 0;
  31. return mCameraDevice;
  32. }
复制代码
通 过android.hardware.Camera.open(cameraId)调用进入下一层封装,JNI层,这一层是java代码的最下层,对下层 CameraC++代码进行JNI封装,封装实现类在Camera.java (android4.0\frameworks\base\core\java\android\hardware) 下面是这个类的部分实现,里面定义了不少回调函数:

  1. public class Camera {
  2. private static final String TAG = "Camera";

  3. // These match the enums in frameworks/base/include/camera/Camera.h
  4. private static final int CAMERA_MSG_ERROR            = 0x001;
  5. private static final int CAMERA_MSG_SHUTTER          = 0x002;
  6. private static final int CAMERA_MSG_FOCUS            = 0x004;
  7. private static final int CAMERA_MSG_ZOOM             = 0x008;
  8. private static final int CAMERA_MSG_PREVIEW_FRAME    = 0x010;
  9. private static final int CAMERA_MSG_VIDEO_FRAME      = 0x020;
  10. private static final int CAMERA_MSG_POSTVIEW_FRAME   = 0x040;
  11. private static final int CAMERA_MSG_RAW_IMAGE        = 0x080;
  12. private static final int CAMERA_MSG_COMPRESSED_IMAGE = 0x100;
  13. private static final int CAMERA_MSG_RAW_IMAGE_NOTIFY = 0x200;
  14. private static final int CAMERA_MSG_PREVIEW_METADATA = 0x400;
  15. private static final int CAMERA_MSG_ALL_MSGS         = 0x4FF;

  16. private int mNativeContext; // accessed by native methods
  17. private EventHandler mEventHandler;
  18. private ShutterCallback mShutterCallback;
  19. private PictureCallback mRawImageCallback;
  20. private PictureCallback mJpegCallback;
  21. private PreviewCallback mPreviewCallback;
  22. private PictureCallback mPostviewCallback;
  23. private AutoFocusCallback mAutoFocusCallback;
  24. private OnZoomChangeListener mZoomListener;
  25. private FaceDetectionListener mFaceListener;
  26. private ErrorCallback mErrorCallback;
复制代码
定位到Open函数:

  1. public static Camera open(int cameraId) {
  2. return new Camera(cameraId);
  3. }
复制代码


Open函数是一个静态方法,构造一个Camera对象:

  1. Camera(int cameraId) {
  2. mShutterCallback = null;
  3. mRawImageCallback = null;
  4. mJpegCallback = null;
  5. mPreviewCallback = null;
  6. mPostviewCallback = null;
  7. mZoomListener = null;

  8. Looper looper;
  9. if ((looper = Looper.myLooper()) != null) {
  10. mEventHandler = new EventHandler(this, looper);
  11. } else if ((looper = Looper.getMainLooper()) != null) {
  12. mEventHandler = new EventHandler(this, looper);
  13. } else {
  14. mEventHandler = null;
  15. }

  16. native_setup(new WeakReference(this), cameraId);
  17. }
复制代码
在构造函数中调用native_setup方法,此方法对应于C++代码的android_hardware_Camera_native_setup方法,
实现在android_hardware_Camera.cpp (android4.0\frameworks\base\core\jni),具体代码如下:

  1. static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,
  2. jobject weak_this, jint cameraId)
  3. {
  4. sp camera = Camera::connect(cameraId);

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

  9. // make sure camera hardware is alive
  10. if (camera->getStatus() != NO_ERROR) {
  11. jniThrowRuntimeException(env, "Camera initialization failed");
  12. return;
  13. }

  14. jclass clazz = env->GetObjectClass(thiz);
  15. if (clazz == NULL) {
  16. jniThrowRuntimeException(env, "Can't find android/hardware/Camera");
  17. return;
  18. }

  19. // We use a weak reference so the Camera object can be garbage collected.
  20. // The reference is only used as a proxy for callbacks.
  21. sp context = new JNICameraContext(env, weak_this, clazz, camera);
  22. context->incStrong(thiz);
  23. camera->setListener(context);

  24. // save context in opaque field
  25. env->SetIntField(thiz, fields.context, (int)context.get());
  26. }
复制代码

在android_hardware_Camera_native_setup方法中调用了Camera对象的connect方法,这个Camera类的 声明在Camera.h (android4.0\frameworks\base\include\camera)
定位到connect方法:

  1. sp Camera::connect(int cameraId)
  2. {
  3. LOGV("connect");
  4. sp c = new Camera();
  5. const sp& 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. return c;
  16. }
复制代码

这里以下的代码就比较关键了,涉及到Camera框架的实现机制,Camera系统使用的是Server-Client机制,Service和Client位于不同的进程中,进程间使用Binder机制进行通信,
Service端实际实现相机相关的操作,Client端通过Binder接口调用Service对应的操作。
继续分析代码,上面函数调用getCameraService方法,获得CameraService的引用,ICameraService有两个子类,BnCameraService和BpCameraService,这两个子类同时也
继承了IBinder接口,这两个子类分别实现了Binder通信的两端,Bnxxx实现ICameraService的具体功能,Bpxxx利用Binder的通信功能封装ICameraService方法,具体如下:

  1. class ICameraService : public IInterface
  2. {
  3. public:
  4. enum {
  5. GET_NUMBER_OF_CAMERAS = IBinder::FIRST_CALL_TRANSACTION,
  6. GET_CAMERA_INFO,
  7. CONNECT
  8. };
复制代码

  1. public:
  2. DECLARE_META_INTERFACE(CameraService);

  3. virtual int32_t         getNumberOfCameras() = 0;
  4. virtual status_t        getCameraInfo(int cameraId,
  5. struct CameraInfo* cameraInfo) = 0;
  6. virtual sp     connect(const sp& cameraClient,
  7. int cameraId) = 0;
  8. };

  9. // ----------------------------------------------------------------------------

  10. class BnCameraService: public BnInterface
  11. {
  12. public:
  13. virtual status_t    onTransact( uint32_t code,
  14. const Parcel& data,
  15. Parcel* reply,
  16. uint32_t flags = 0);
  17. };

  18. }; // na
  19. class BpCameraService: public BpInterface
  20. {
  21. public:
  22. BpCameraService(const sp& impl)
  23. : BpInterface(impl)
  24. {
  25. }

  26. // get number of cameras available
  27. virtual int32_t getNumberOfCameras()
  28. {
  29. Parcel data, reply;
  30. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  31. remote()->transact(BnCameraService::GET_NUMBER_OF_CAMERAS, data, &reply);
  32. return reply.readInt32();
  33. }

  34. // get information about a camera
  35. virtual status_t getCameraInfo(int cameraId,
  36. struct CameraInfo* cameraInfo) {
  37. Parcel data, reply;
  38. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  39. data.writeInt32(cameraId);
  40. remote()->transact(BnCameraService::GET_CAMERA_INFO, data, &reply);
  41. cameraInfo->facing = reply.readInt32();
  42. cameraInfo->orientation = reply.readInt32();
  43. return reply.readInt32();
  44. }

  45. // connect to camera service
  46. virtual sp connect(const sp& cameraClient, int cameraId)
  47. {
  48. Parcel data, reply;
  49. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  50. data.writeStrongBinder(cameraClient->asBinder());
  51. data.writeInt32(cameraId);
  52. remote()->transact(BnCameraService::CONNECT, data, &reply);
  53. return interface_cast(reply.readStrongBinder());
  54. }
  55. };

  56. IMPLEMENT_META_INTERFACE(CameraService, "android.hardware.ICameraService");

  57. // ----------------------------------------------------------------------

  58. status_t BnCameraService::onTransact(
  59. uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
  60. {
  61. switch(code) {
  62. case GET_NUMBER_OF_CAMERAS: {
  63. CHECK_INTERFACE(ICameraService, data, reply);
  64. reply->writeInt32(getNumberOfCameras());
  65. return NO_ERROR;
  66. } break;
  67. case GET_CAMERA_INFO: {
  68. CHECK_INTERFACE(ICameraService, data, reply);
  69. CameraInfo cameraInfo;
  70. memset(&cameraInfo, 0, sizeof(cameraInfo));
  71. status_t result = getCameraInfo(data.readInt32(), &cameraInfo);
  72. reply->writeInt32(cameraInfo.facing);
  73. reply->writeInt32(cameraInfo.orientation);
  74. reply->writeInt32(result);
  75. return NO_ERROR;
  76. } break;
  77. case CONNECT: {
  78. CHECK_INTERFACE(ICameraService, data, reply);
  79. sp cameraClient = interface_cast(data.readStrongBinder());
  80. sp camera = connect(cameraClient, data.readInt32());
  81. reply->writeStrongBinder(camera->asBinder());
  82. return NO_ERROR;
  83. } break;
  84. default:
  85. return BBinder::onTransact(code, data, reply, flags);
  86. }
  87. }

  88. // ----------------------------------------------------------------------------

  89. }; // namespace android
复制代码
下面继续分析sp Camera::connect(int cameraId)这个方法,,定位到getCameraService这个方法

  1. const sp& Camera::getCameraService()
  2. {
  3. Mutex::Autolock _l(mLock);
  4. if (mCameraService.get() == 0) {
  5. sp sm = defaultServiceManager();
  6. sp binder;
  7. do {
  8. binder = sm->getService(String16("media.camera"));
  9. if (binder != 0)
  10. break;
  11. LOGW("CameraService not published, waiting...");
  12. usleep(500000); // 0.5 s
  13. } while(true);
  14. if (mDeathNotifier == NULL) {
  15. mDeathNotifier = new DeathNotifier();
  16. }
  17. binder->linkToDeath(mDeathNotifier);
  18. mCameraService = interface_cast(binder);
  19. }
  20. LOGE_IF(mCameraService==0, "no CameraService!?");
  21. return mCameraService;
  22. }
复制代码

定位到mCameraService = interface_cast(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引用,


c->mCamera = cs->connect(c, cameraId);


进一步跟进connect方法,这里就是BpCameraService类中connect方法的具体实现。

  1. virtual sp connect(const sp& cameraClient, int cameraId)
  2. {
  3. Parcel data, reply;
  4. data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
  5. data.writeStrongBinder(cameraClient->asBinder());
  6. data.writeInt32(cameraId);
  7. remote()->transact(BnCameraService::CONNECT, data, &reply);
  8. return interface_cast(reply.readStrongBinder());
  9. }
复制代码
在这里返回的ICamera对象,实际上应该是BpCamera对象,这里使用的是匿名Binder,前面获取CameraService的 使用的有名Binder,有名Binder需要借助于ServiceManager获取Binder,而匿名Binder可以通过已经建立后的通信通道 (有名Binder)获得。以上是实现Camera框架部分,具体的实现Camera相关的方法是在ICamera相关的接口,下面是给接口的定义:

  1. class ICamera: public IInterface
  2. {
  3. public:
  4. DECLARE_META_INTERFACE(Camera);
  5. virtual void            disconnect() = 0;
  6. // connect new client with existing camera remote
  7. virtual status_t        connect(const sp& client) = 0;
  8. // prevent other processes from using this ICamera interface
  9. virtual status_t        lock() = 0;
  10. // allow other processes to use this ICamera interface
  11. virtual status_t        unlock() = 0;
  12. // pass the buffered Surface to the camera service
  13. virtual status_t        setPreviewDisplay(const sp& surface) = 0;
  14. // pass the buffered ISurfaceTexture to the camera service
  15. virtual status_t        setPreviewTexture(
  16. const sp& surfaceTexture) = 0;
  17. // set the preview callback flag to affect how the received frames from
  18. // preview are handled.
  19. virtual void            setPreviewCallbackFlag(int flag) = 0;
  20. // start preview mode, must call setPreviewDisplay first
  21. virtual status_t        startPreview() = 0;
  22. // stop preview mode
  23. virtual void            stopPreview() = 0;
  24. // get preview state
  25. virtual bool            previewEnabled() = 0;
  26. // start recording mode
  27. virtual status_t        startRecording() = 0;
  28. // stop recording mode
  29. virtual void            stopRecording() = 0;
  30. // get recording state
  31. virtual bool            recordingEnabled() = 0;
  32. // release a recording frame
  33. virtual void            releaseRecordingFrame(const sp& mem) = 0;
  34. // auto focus
  35. virtual status_t        autoFocus() = 0;
  36. // cancel auto focus
  37. virtual status_t        cancelAutoFocus() = 0;
  38. virtual status_t        takePicture(int msgType) = 0;
  39. // set preview/capture parameters - key/value pairs
  40. virtual status_t        setParameters(const String8& params) = 0;
  41. // get preview/capture parameters - key/value pairs
  42. virtual String8         getParameters() const = 0;
  43. // send command to camera driver
  44. virtual status_t        sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;
  45. // tell the camera hal to store meta data or real YUV data in video buffers.
  46. virtual status_t        storeMetaDataInBuffers(bool enabled) = 0;
  47. };
复制代码
ICamera接口有两个子类BnCamera和BpCamera,是Binder通信的两端,BpCamera提供客户端调用 接口,BnCamera封装具体的实现,BnCamera也并没有真正实现ICamera相关接口而是在BnCamera子类 CameraService::Client中进行实现。而在CameraService::Client类中会继续调用硬件抽象层中相关方法来具体实现Camera功能。


本文地址:https://www.eechina.com/thread-121041-1-1.html     【打印本页】

本站部分文章为转载或网友发布,目的在于传递和分享信息,并不代表本网赞同其观点和对其真实性负责;文章版权归原作者及原出处所有,如涉及作品内容、版权和其它问题,我们将根据著作权人的要求,第一时间更正或删除。
您需要登录后才可以发表评论 登录 | 立即注册

厂商推荐

相关视频

关于我们  -  服务条款  -  使用指南  -  站点地图  -  友情链接  -  联系我们
电子工程网 © 版权所有   京ICP备16069177号 | 京公网安备11010502021702
快速回复 返回顶部 返回列表