前面已经分析过，Client端发起远程调用，而实际完成处理任务的，是Server端的 CameraClient 实例。远程client 和 server是两个不同的进程，它们使用binder作为通信工具，完成进程间的通信。
注：CameraClient定义如下:
class CameraClient : public CameraService::Client
{
//...
};
App需要对Camera进行各种操作，framework-java 和framework-c++ 都有对应的操作接口。而JNI是framework-java 和framework-c++ 中间的通信桥梁。
在framework-c++ 这边，或者说在 CameraClient 实例里面，会和 HAL层进行沟通。
本篇笔记将就 framework-java、framework-c++ 、HAL相关接口作一个简要笔记。App层属于摄像头应用功能逻辑部分，尚未研究。
一、JNI 封装接口
1. JNI method 表注册
framework-c++ 为 framework-java实现了对应的接口，具体在 android_hardware_Camera.cpp 文件中:
static JNINativeMethod camMethods[] = {
{ "getNumberOfCameras",
"()I",
(void *)android_hardware_Camera_getNumberOfCameras },
{ "_getCameraInfo",
"(ILandroid/hardware/Camera$CameraInfo;)V",
(void*)android_hardware_Camera_getCameraInfo },
{ "native_setup",
"(Ljava/lang/Object;IILjava/lang/String;)I",
(void*)android_hardware_Camera_native_setup },
{ "native_release",
"()V",
(void*)android_hardware_Camera_release },
{ "setPreviewSurface",
"(Landroid/view/Surface;)V",
(void *)android_hardware_Camera_setPreviewSurface },
{ "setPreviewTexture",
"(Landroid/graphics/SurfaceTexture;)V",
(void *)android_hardware_Camera_setPreviewTexture },
{ "setPreviewCallbackSurface",
"(Landroid/view/Surface;)V",
(void *)android_hardware_Camera_setPreviewCallbackSurface },
{ "startPreview",
"()V",
(void *)android_hardware_Camera_startPreview },
{ "_stopPreview",
"()V",
(void *)android_hardware_Camera_stopPreview },
{ "previewEnabled",
"()Z",
(void *)android_hardware_Camera_previewEnabled },
{ "setHasPreviewCallback",
"(ZZ)V",
(void *)android_hardware_Camera_setHasPreviewCallback },
{ "_addCallbackBuffer",
"([BI)V",
(void *)android_hardware_Camera_addCallbackBuffer },
{ "native_autoFocus",
"()V",
(void *)android_hardware_Camera_autoFocus },
{ "native_cancelAutoFocus",
"()V",
(void *)android_hardware_Camera_cancelAutoFocus },
{ "native_takePicture",
"(I)V",
(void *)android_hardware_Camera_takePicture },
{ "native_setParameters",
"(Ljava/lang/String;)V",
(void *)android_hardware_Camera_setParameters },
{ "native_getParameters",
"()Ljava/lang/String;",
(void *)android_hardware_Camera_getParameters },
{ "reconnect",
"()V",
(void*)android_hardware_Camera_reconnect },
{ "lock",
"()V",
(void*)android_hardware_Camera_lock },
{ "unlock",
"()V",
(void*)android_hardware_Camera_unlock },
{ "startSmoothZoom",
"(I)V",
(void *)android_hardware_Camera_startSmoothZoom },
{ "stopSmoothZoom",
"()V",
(void *)android_hardware_Camera_stopSmoothZoom },
{ "setDisplayOrientation",
"(I)V",
(void *)android_hardware_Camera_setDisplayOrientation },
{ "_enableShutterSound",
"(Z)Z",
(void *)android_hardware_Camera_enableShutterSound },
{ "_startFaceDetection",
"(I)V",
(void *)android_hardware_Camera_startFaceDetection },
{ "_stopFaceDetection",
"()V",
(void *)android_hardware_Camera_stopFaceDetection},
{ "enableFocusMoveCallback",
"(I)V",
(void *)android_hardware_Camera_enableFocusMoveCallback},
};
其中，双引号里的名字，对应着 framework-java 层Camera.java 文件中相关的API；以 "android_hardware_Camera_"为前缀的名字，代表着 framework-c++ 中的实现。至于其中返回值和参数类型的表示，此处略去。
可以看出，一个java API 就对应着一个 C++ API实现。
camMethods[] 这个表会被注册到 const RegJNIRec gRegJNI[] 这个表中，而这个表将会被系统进行native注册，大致如下:
(1).在android_hardware_Camera.cpp文件中:
int register_android_hardware_Camera(JNIEnv *env)
{
//...
// Register native functions
return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",
camMethods, NELEM(camMethods));
};
(2).在AndroidRuntime.cpp 文件中:
extern int register_android_hardware_Camera(JNIEnv *env);
static const RegJNIRec gRegJNI[] = {
REG_JNI(register_android_hardware_Camera),
};
/*
* Register android native functions with the VM.
*/
/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
//...
if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < ) {
env->PopLocalFrame(NULL);
return -;
}
//...
}
void AndroidRuntime::start(const char* className, const Vector<String8>& options)
{
//...
/*
* Register android functions.
*/
if (startReg(env) < ) {
ALOGE("Unable to register all android natives\n");
return;
}
//...
}
此处注册流程，大致这样，不再赘述jvm native注册细节。
2. JNI method 表中c++接口的实现
在 android_hardware_Camera.cpp 文件中，这些c++ 接口只是一层空壳，可以简单的看成是一些环境变量、字符串类型的转换而已。
(此处截取部分接口的封装实现进行展示)
static jint android_hardware_Camera_getNumberOfCameras(JNIEnv *env, jobject thiz)
{
//调用了 Camera.cpp 文件中的接口。
return Camera::getNumberOfCameras();
} // connect to camera service
static jint android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,
jobject weak_this, jint cameraId, jint halVersion, jstring clientPackageName)
{
sp<Camera> camera;
//调用了 Camera.cpp 文件中的接口
camera = Camera::connect(cameraId, clientName,Camera::USE_CALLING_UID);
} static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
{
ALOGV("startPreview");
sp<Camera> camera = get_native_camera(env, thiz, NULL); //获取一个Camera 实例
if (camera == ) return; //调用了 Camera.cpp 文件中 Camera::startPreview()
if (camera->startPreview() != NO_ERROR) {
jniThrowRuntimeException(env, "startPreview failed");
return;
}
}
....
而真正的封装，在 Camera.cpp 文件中实现。
二、远端 Camera client
在Camera.cpp文件中,部分接口如下:
sp<Camera> Camera::connect(int cameraId, const String16& clientPackageName,int clientUid);
status_t Camera::reconnect();
status_t Camera::lock();
status_t Camera::unlock();
// pass the buffered IGraphicBufferProducer to the camera service
status_t Camera::setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer);
// start preview mode
status_t Camera::startPreview();
status_t Camera::storeMetaDataInBuffers(bool enabled);
// start recording mode, must call setPreviewTarget first
status_t Camera::startRecording();
// stop preview mode
void Camera::stopPreview();
// stop recording mode
void Camera::stopRecording();
// release a recording frame
void Camera::releaseRecordingFrame(const sp<IMemory>& mem);
// get preview state
bool Camera::previewEnabled();
// get recording state
bool Camera::recordingEnabled();
status_t Camera::autoFocus();
status_t Camera::cancelAutoFocus();
// take a picture
status_t Camera::takePicture(int msgType);
// set preview/capture parameters - key/value pairs
status_t Camera::setParameters(const String8& params);
// send command to camera driver
status_t Camera::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
.....
上面的这些接口，会被android_hardware_Camera.cpp 文件中的对应名字的接口进行调用，以完成jni的封装。
三、server 端 CameraClient 的实例接口
在前一篇笔记里已经分析过， Camera Client远端的操作，其实质是通过binder，然后调用到了Camera server端对应的接口。而具体就落实到了 CameraService::Client 内部类的 继承类 CameraClient 的实例上去了。
在CameraClient.cpp文件中，server端为远程client端实现了对应的接口:
status_t CameraClient::lock();
status_t CameraClient::unlock(); // connect a new client to the camera
status_t CameraClient::connect();
void CameraClient::disconnect() ; status_t CameraClient::setPreviewWindow(const sp<IBinder>& binder,const sp<ANativeWindow>& window);
// set the buffer consumer that the preview will use
status_t CameraClient::setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer); // start preview mode
status_t CameraClient::startPreview() ;
// start recording mode
status_t CameraClient::startRecording();
// start preview or recording
status_t CameraClient::startCameraMode(camera_mode mode);
status_t CameraClient::startPreviewMode();
status_t CameraClient::startRecordingMode() ;
// stop preview mode
void CameraClient::stopPreview();
// stop recording mode
void CameraClient::stopRecording(); bool CameraClient::previewEnabled(); status_t CameraClient::initialize(camera_module_t *module); .....
以上仅贴出部分常见的接口。
在上面贴出来的接口中，CameraClient::initialize() 是最重要的。在 CameraService::connect() 对 CameraClient::connect() 完成调用后，会立即对CameraClient::initialize() 进行调用，去操作HAL层，已完成一个Camera实例的最终创建。
(CameraClient::initialize()被调用流程，在上篇笔记已经分析过，此处不赘述)
CameraClient::initialize()被调用后，将会去调用 HAL 层的 open 函数。换句话说，它会打开HAL模块。
status_t CameraClient::initialize(camera_module_t *module)
{
//...
mHardware = new CameraHardwareInterface(camera_device_name);
res = mHardware->initialize(&module->common);
//....
}
mHardware->initialize() 的实现在 CameraHardwareInterface.h 文件中：
class CameraHardwareInterface : public virtual RefBase {
public:
status_t initialize(hw_module_t *module)
{
camera_module_t *cameraModule = reinterpret_cast<camera_module_t *>(module);
int rc = OK;
if (module->module_api_version >= CAMERA_MODULE_API_VERSION_2_3 && info.device_version > CAMERA_DEVICE_API_VERSION_1_0)
//....
} else {
rc = CameraService::filterOpenErrorCode(module->methods->open(
module, mName.string(), (hw_device_t **)&mDevice));
}
//...
}
}；
这其中的 module->methods->open(module, mName.string(), (hw_device_t **)&mDevice) ； 就是HAL模块的入口处了。
那么，camera_module_t *module 这个参数是怎么传进来的呢？或者说，Camera HAL模块式怎么加载到内存的呢？
对代码稍作回朔，可以知道，在 CameraService::onFirstRef() 这个接口里面，有加载Camera HAL的操作,在 CameraService.cpp 文件中：
void CameraService::onFirstRef()
{
//..
BnCameraService::onFirstRef();
//..
if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,(const hw_module_t **)&mModule) < ) {
}else {
//...
}
}
大名鼎鼎的 hw_get_module() 接口在这里现身了。那么，CameraService::onFirstRef()又是在什么时候被调用的呢？
简而言之，在远端client发起连接的时候，在文件 CameraBase.cpp 中:
template <typename TCam, typename TCamTraits>
sp<TCam> CameraBase<TCam, TCamTraits>::connect(int cameraId,
const String16& clientPackageName,
int clientUid)
{
sp<TCam> c = new TCam(cameraId); //通过SM获取CameraService在本地的一个引用。调用connect函数后最终调用CameraService侧的connect()函数
const sp<ICameraService>& cs = getCameraService();
//...
}
这里， const sp<ICameraService>& cs = getCameraService(); 这行代码其实可以被分解成两行代码：
ICameraService *A = getCameraService(); //不考虑c++ 实际语法
const sp<ICameraService>& cs = A; //不考虑c++ 实际语法
在第二行代码执行的时候，在构造强指针的过程中，最终会调用到 CameraService::onFirstRef() 这个玩意. 其具体调用处，在 RefBase.cpp 文件中：
void RefBase::incStrong(const void* id) const
{
//...
refs->mBase->onFirstRef();
}
其具体调用流程略掉了。(这里涉及到Android 中sp wp 所谓的强指针弱指针构造的过程)
啰嗦了一长段，回头看看 CameraClient::initialize() 会为其他接口提供什么样的帮助：
status_t CameraClient::initialize(camera_module_t *module)
{
//...
mHardware = new CameraHardwareInterface(camera_device_name);
//....
}
mHardware 是 CameraClient 的一个成员，在CameraClient.h文件中：
class CameraClient : public CameraService::Client
{
private:
// these are initialized in the constructor.
sp<CameraHardwareInterface> mHardware;
}；
根据定义可以看见， mHardware 就是一个 CameraHardwareInterface 的 sp 对象----也就是HAL层的东西了。
而CameraClient中的大部分成员函数，都会借助 mHardware 成员，操作HAL层。(什么叫操作？！总是很邪恶的感觉到，它们是在推卸责任，把责任一层层的推卸，最后就到了HAL,HAL又会推到最终的driver上)
贴停止预览和照相的代码做为一个展示:
// take a picture - image is returned in callback
status_t CameraClient::takePicture(int msgType) {
//...
return mHardware->takePicture(); //告诉HAL层，进行拍照操作
} // stop preview mode
void CameraClient::stopPreview() {
//...
mHardware->stopPreview(); //告诉HAL层，停止预览
}
四、HAL 接口
在 CameraClient::initialize()中，会产生一个 HAL 的 sp 对象:
mHardware = new CameraHardwareInterface(camera_device_name);
这里， CameraHardwareInterface 类，就对HAL层做了一个接口抽象,其定义在 CameraHardwareInterface.h 文件中。
class CameraHardwareInterface : public virtual RefBase {
public:
CameraHardwareInterface(const char *name)
{
mDevice = ;
mName = name;
}
status_t initialize(hw_module_t *module)
{
rc = CameraService::filterOpenErrorCode(module->methods->open(
module, mName.string(), (hw_device_t **)&mDevice));
}
/**
* Start preview mode.
*/
status_t startPreview()
{
ALOGV("%s(%s)", __FUNCTION__, mName.string());
if (mDevice->ops->start_preview)
return mDevice->ops->start_preview(mDevice);
return INVALID_OPERATION;
}
/**
* Stop a previously started preview.
*/
void stopPreview()
{
ALOGV("%s(%s)", __FUNCTION__, mName.string());
if (mDevice->ops->stop_preview)
mDevice->ops->stop_preview(mDevice);
}
//.....省略
private:
camera_device_t *mDevice;
String8 mName;
//... 省略
};
显而易见，这里是对 Camera HAL 的一个抽象封装，毕竟，各种厂商的Camera HAL 具体模块，其实现细节可能不同。于是这里就再抽了一层。
其扮演的角色，其实和 android_hardware_Camera.cpp 文件中，jni那部分接口一样。为了好看(更清晰)，包装了一层而已。
只要CameraService::onFirstRef()中对Camera HAL模块加载成功，这里就可以开始告诉Camera HAL 做什么。至于怎么做，那将是HAL层的事---话说，这是面向对象的基本原理吧:只能告诉别人做什么，具体怎么做，就管不了了。
全文总结：
App ---> framework-java ---> jni ---> framework-c++(Camera) ---> binder ---> framework-c++(CameraService) --> framework-c++(CameraService::Client) ---> framework-c++(CameraClient) --->(CameraHardwareInterface) ---> HAL
由于未对 framework-java 以上的东西进行分析，笔记中直接从 jni 开始的。
(over)
2016-1-22