Android Camera Framework Stream(二)

接下来，我们通过对流程的步步分析来将

camera


整体串接起来

:



1．

首先则看看
camera.java


的
onCreate

函数入口，针对
android

的所有应用，
onCreate

函数入口作为跟踪和了解应用架构的首选。

@Override

public void onCreate(Bundle icicle) {

super.onCreate(icicle);

devlatch = new CountDownLatch(1);

CountDownLatch()


关于这个类，可以简单的理解为它是用来线程之间的等待处理，当然这里采用的计数为
1

，则可以简单理解为一个计数开关来控制调用了
tlatch.await()

函数的进程，方式就是将
devlatch

的计数减为
0(countDown()
)

。

这里启动了一个线程用来打开
camera

服务，而打开过程则比较费时
(

一般在
2s

左右
)

，故单独启用一个线程避免应用线程阻塞。

Thread startPreviewThread = new Thread(new Runnable() {

CountDownLatch tlatch = devlatch;

public void run() {

try {

mStartPreviewFail = false;

ensureCameraDevice();

// Wait for framework initialization to be complete before

// starting preview

try {

tlatch.await();

} catch (InterruptedException ie) {

mStartPreviewFail = true;

}

startPreview();

} catch (CameraHardwareException e) {

// In eng build, we throw the exception so that test tool

// can detect it and report it

if ("eng".equals(Build.TYPE)) {

throw new RuntimeException(e);

}

mStartPreviewFail = true;

}

}

});

startPreviewThread.start();

在这里，需要跟进
ensureCameraDevice();

该函数，可以看到其实现为：

private void ensureCameraDevice() throws CameraHardwareException {

if (mCameraDevice == null) {

mCameraDevice = CameraHolder.instance().open();

mInitialParams = mCameraDevice.getParameters();

}

}

当前
mCameraDevice()

实例为
null,

则会调用
CameraHolder.instance().open()

函数来创建
mCameraDevice

对象实例。

private android.hardware.Camera mCameraDevice;

跟进
CameraHolder.instance().open()

，进入到了
CameraHolder

类中：

public synchronized android.hardware.Camera open()

throws CameraHardwareException {

Assert(mUsers == 0);

if (mCameraDevice == null) {

try {

mCameraDevice = android.hardware.Camera.open();

} catch (RuntimeException e) {

Log.e(TAG, "fail to connect Camera", e);

throw new CameraHardwareException(e);

}

mParameters = mCameraDevice.getParameters();

} else {

……

下面大概介绍下我对
CameraHolder

的理解：

1

、
CameraHolder

对
mCameraDevice

实例进行短暂的保留
(keep()

函数中可以设定这个保留时长
,

一般默认为
3000ms)

，避免用户在短暂退出
camera

又重新进入时，缩短
camera

启动时长
(

正如之前所说，打开
CameraDevice

时间较长
)

2

、
CameraHolder

并有一个关键的计数
mUsers

用来保证
open()

和
release()

的配套调用，避免多次重复释放或者打开
(

上层应用的保护措施之一
)

。

2．

第一步的完成，进而跳转到了
android.hardware.Camera

类中的
open()

函数接口调用。

public static Camera open() {

return new Camera();

}

静态函数，也就可以通过类名直接调用，
open()

函数中去创建一个
Camera

的实例。

Camera() {

mShutterCallback = null;

mRawImageCallback = null;

mJpegCallback = null;

mPreviewCallback = null;

mPostviewCallback = null;

mZoomListener = null;

Looper looper;

if ((looper = Looper.myLooper()) != null) {

mEventHandler = new EventHandler(this, looper);

} else if ((looper = Looper.getMainLooper()) != null) {

mEventHandler = new EventHandler(this, looper);

} else {

mEventHandler = null;

}

native_setup(new WeakReference<Camera>(this));

}

在
Camera

构造函数中有这个关键的一步
,

最开始的一些
callback

可以认为它们最终被底层调用到
(

至于具体流程后面会讲到
)

。
EventHandler

和
Looper

我们暂时跳过，知道它是消息处理就行了。最后也就是最为关键的函数接口调用：
native_setup

private native final void native_setup(Object camera_this);

典型的
native

函数接口声明，说明并非
camera

类的本地函数实现，也就意味着会通过
JNI(Java Native Interface)

调用对用
C++

文件中的函数接口。

3．

通过代码搜索，或者如果你清楚
JNI

文件路径也可以去该路径下找。

其实这边有个小技巧，虽然不一定都通用，但可以试试看：

java

类的
package

名往往可以作为寻找相应
JNI

文件的途径：

package android.hardware;

则就可以通过
android.hardware.


camera.cpp

来寻找
(

其实还是归咎于
android

的规范命名规则
)

。

跳转到
android_hardware_Camera.cpp


中寻找
native_setup()

所对应的
JNI

函数接口：

static JNINativeMethod camMethods[] = {

{ "native_setup",

"(Ljava/lang/Object;)V",

(void*)android_hardware_Camera_native_setup },

{ "native_release",

"()V",

(void*)android_hardware_Camera_release },

{ "setPreviewDisplay",

"(Landroid/view/Surface;)V",

(void *)android_hardware_Camera_setPreviewDisplay },

……

而
camMethods[]

在什么时候映射的那？继续看：

int register_android_hardware_Camera(JNIEnv *env)
{

…..

// Register native functions

return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",

camMethods,NELEM(camMethods));

}

最终在
AndroidRuntime.cpp

中被调用：

REG_JNI(register_android_hardware_Camera),

说明如果我们自己要添加
JNI

接口实现的话，这些地方也需要添加相应的代码
(

具体在
AndroidRuntime.cpp

的细节我没深看，也不做介绍
)

。

简单介绍：


JNINativeMethod

的第一个成员是一个字符

串，表示了
JAVA

本地调用方法的名称，这个名称是在
JAVA

程序中调用的名称；第二个成员也是一个字符串，表示
JAVA

本地调用方法的参数和返回值；第三个成员是
JAVA

本地调用方法对应的
C

语言函数
。

跟进观察
android_hardware_Camera_native_setup()

函数的实现：

// connect to camera service

static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)

{

sp<Camera> camera =
Camera::connect();

if (camera == NULL) {

jniThrowException(env, "java/lang/RuntimeException",

"Fail to connect to camera service");

return;

}

….

}

初步可以认为
Camera::connect()

的函数调用时返回了一个
Camera

的实例对象。

4．

通过上述的跟进流程来到了针对上层应用而言最为直接的类：
camera.cpp

：

对
Camera::connect

函数的调用如下：

sp<Camera> Camera::connect()

{

LOGV("connect");

sp<Camera> c =
new Camera();

const sp<ICameraService>& cs =
getCameraService();

if (cs != 0) {

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

}

if (c->mCamera != 0) {

c->mCamera->asBinder()->linkToDeath(c);

c->mStatus = NO_ERROR;

} else {

c.clear();

}

return c;

}

首先是创建一个
camera

对象实例，然后通过调用
getCameraService()

去取得
ICameraService


的服务实例：

// establish binder interface to camera service

const sp<ICameraService>& Camera::getCameraService()

{

Mutex::Autolock _l(mLock);

if (mCameraService.get() == 0) {

sp<IServiceManager> sm =
defaultServiceManager()
;

sp<IBinder> binder;

do {

binder = sm->getService(String16("media.camera"));

if (binder != 0)

break;

LOGW("CameraService not published, waiting...");

usleep(500000); // 0.5 s

} while(true);

if (mDeathNotifier == NULL) {

mDeathNotifier = new DeathNotifier();

}

binder->linkToDeath(mDeathNotifier);

mCameraService = interface_cast<ICameraService>(binder);

}

LOGE_IF(mCameraService==0, "no CameraService!?");

return mCameraService;

}

这边就涉及到了
ServiceManager()

对服务的管理，在这之前
Camera

的服务已经注册到了
ServiceManager

中，我们可以通过服务字串
(media.camera)

来获得
camera service(

其本质得到的是
CameraService

的实例对象，虽然通过类型上溯转换成父类
ICameraService

，对
ICameraService

对象的函数调用本质是调用到了
CameraService

的函数实现

)

。

在得到
camera service

后，返回之前的步骤：当得到的
cs

即
cameraservice

实例存在时，通过调用
cs->connect(c)

去得到
ICamera

实例，并赋值给了
camera

实例的一个类成员
ICamera

mCamera

：

if (cs != 0) {

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

5．

接下来则涉及到ICamraService

的相关调用关系，其实这个地方需要去弄清楚一些函数接口的实现在具体哪些文件中，因为存在较多的虚函数。

继续流程，上一步走到了
cs->connect()

，也就是
ICameraService


的
connect()

函数接口。

class ICameraService : public IInterface

{

public:

enum {

CONNECT = IBinder::FIRST_CALL_TRANSACTION,

};

public:

DECLARE_META_INTERFACE(CameraService);

virtual sp<ICamera>
connect(const sp<ICameraClient>& cameraClient) = 0;

};

可以发现该connect()

接口为一个纯虚函数，需要
ICameraService

的子类对该接口进行实现，从而对connect()

的调用则会映射到
ICameraService

子类的具体实现。

关于
ICameraService

的实例问题，目前暂时跳过
(

后面马上就会讲到
)

，简单认为这个时候会调用到其一个子类的实现：

class BpCameraService: public BpInterface<ICameraService>

{

public:

BpCameraService(const sp<IBinder>& impl)

:
BpInterface<ICameraService>(impl)

{

}

// connect to camera service

virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient)

{

Parcel data, reply;

data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());

data.writeStrongBinder(cameraClient->asBinder());

remote()->transact(BnCameraService::CONNECT, data, &reply);

return interface_cast<ICamera>(reply.readStrongBinder());

}

};

BpCameraService

为代理类，其主要用途为
Binder

通讯机制即进程间的通讯
(Client/Service)

，最终还是会调用
BnCameraService

的具体实现，即：

status_t
BnCameraService::onTransact
(

uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

switch(code) {

case CONNECT: {

CHECK_INTERFACE(ICameraService, data, reply);

sp<ICameraClient> cameraClient

= interface_cast<ICameraClient>(data.readStrongBinder());

sp<ICamera> camera = connect(cameraClient);

reply->writeStrongBinder(camera->asBinder());

return NO_ERROR;

} break;

default:

return BBinder::onTransact(code, data, reply, flags);

}

}

而BnCameraService

(
为实现类
)
类继承于ICameraService

，并且也并没有对connect()

纯虚函数进行了实现，同样意味着其实该调用的实质是
BnCameraService

的子类实现。

毕竟虚函数的调用没有实例肯定是没有意义的，说明我们需要找到对
connect()

纯虚函数的实现子类即继承于
BnCameraService

。

6．

结合上面所述，可以寻找到了继承于BnCameraService

的子类CameraService.cpp

：

这时虽然找到了CameraService

该类，但是你肯定会问到该类实例的创建在什么地方哪？再后头看
CameraService


启动注册的地方：

int main(int argc, char** argv)

{

sp<ProcessState> proc(ProcessState::self());

sp<IServiceManager> sm = defaultServiceManager();

LOGI("ServiceManager: %p", sm.get());

AudioFlinger::instantiate();

MediaPlayerService::instantiate();

CameraService::instantiate();

AudioPolicyService::instantiate();

ProcessState::self()->startThreadPool();

IPCThreadState::self()->joinThreadPool();

}

这个
main

函数位于
main_mediaserver.cpp


中，而
mediaserver

是在系统开始的时候就启动起来的
server

端（MediaServer
，在系统启动时由
init
所启动，具可参考
init.rc
文件
），进而将相关的服务也创建了实例。

跟进
CameraService::instantiate()

函数实现，可以发现：

void CameraService::instantiate() {

defaultServiceManager()->addService(

String16("
media.camera
"),
new CameraService()
);

}

创建了一个
CameraService

实例

，并给定了
CameraService

的服务字串为
”media.camera”

，而之前在通过
ServiceManager

获取
CameraService

的时候，所调用的接口为binder = sm->getService(String16("media.camera"));

，两者保持了一样的字符串。

if (mCameraService.get() == 0) {

sp<IServiceManager> sm = defaultServiceManager();

sp<IBinder> binder;

do {

binder = sm->getService(String16("media.camera"));

if (binder != 0)

break;

LOGW("CameraService not published, waiting...");

usleep(500000); // 0.5 s

} while(true);

if (mDeathNotifier == NULL) {

mDeathNotifier = new DeathNotifier();

}

binder->linkToDeath(mDeathNotifier);

mCameraService = interface_cast<ICameraService>(binder);

}

结合上述分析，此处的binder

对象其实为CameraService

类实例
(

多态类型转换
)

。

interface_cast<ICameraService>(binder)


宏映射，需要展开：

template<typename INTERFACE>

inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)

{

return INTERFACE::asInterface(obj);

}

INTERFACE::asInterface(obj);


宏映射，继续展开可得：

sp<I##INTERFACE> I##INTERFACE::asInterface(const sp<IBinder>& obj)
/

{

/

sp<I##INTERFACE> intr;

/

if (obj != NULL) {

/

intr = static_cast<I##INTERFACE*>(

/

obj->queryLocalInterface(
/

I##INTERFACE::descriptor).get());

/

if (intr == NULL) {

/

intr = new Bp##INTERFACE(obj);

/

}

/

}

/

return intr;

/

}

(

其上的宏展开都是在
IMPLEMENT_META_INTERFACE(CameraService, "android.hardware.ICameraService");


中实现的
)

此处又创建了一个BpCameraService

(new Bp##INTERFACE)

对象并将binder

对象
(obj)

传入到
BpCameraService

的构造函数中。

虽然获取的时候通过多态将
CameraService

实例转换成了
BnCameraService

也进一步解释了为什么
ICameraService
子类
BnCameraservice
中的
connect
函数实质会调用到
CameraService
中函数实现了。

于是就调用到了
CameraService

的
connect

函数接口：

sp<ICamera> CameraService::connect(const sp<ICameraClient>& cameraClient) {

…..

// create a new Client object

client = new Client(this, cameraClient, callingPid);

mClient = client;

if (client->mHardware == NULL) {

client = NULL;

mClient = NULL;

return client;

}

…..

}

创建了一个
Client

实例对象，并将该实例对象赋值给
CameraSevice

的类成员
mClient,

方便其实函数接口对
Client

的调用。

在这之前需要提及它的一个内部类
Client
，该类才是最为关键的函数实现
,CameraService
的一些接口都会调用到其
Client
实例的具体函数。