学步园

Android之Camera服务分析

 Android系统中Camera是作为mediaservice服务中的一项，在开机过程中启动的。

/frameworsk/base/media/mediaserver/main_mediaserver.cpp:

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();
}

/frameworks/base/services/camera/libcameraservice/CameraService.cpp：
我们在CameraSerivce.cpp文件中并没找到CameraService::instantiate()，但是我们在CameraService.h文件中发现：CameraService同时继承于两个类：BinderService<CameaService> 和 BnCameraSerivce。

/frameworks/base/services/camera/libcameraservice/CameraSerivce.h：

class MemoryHeapBase;
class MediaPlayer;
class CameraHardwareInterface;

class CameraService :
    public BinderService<CameraService>,
    public BnCameraService
{
    class Client;
    friend class BinderService<CameraService>;
public:
    static char const* getServiceName() { return "media.camera"; }

                        CameraService();
    virtual             ~CameraService();

    .............

};

       我们找到CameraService的父类：BinderService<SERVICE>它是一个模板类，替换之后就是：

class BinderService<CameraService>

{

public:

       static status_t publish() {

            sp<IServiceManager> sm(defaultServiceManager());

            return sm->addService(String(CameraService::getServiceName()),
new CameraServiec());

       } 

        static void instantiate() { publish(); }

}

所以CameraService::instantiate();最后调用的还是：sm->addService("media.camera", new CameraService())；将自己加入到ServiceManager的服务链表中。

CameraService作为BnCameraService的实现类，在Binder通信机制中是最终调用到的函数的类。

class BnCameraService: public BnInterface<ICameraService>
{
public:
    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
};

主要提供onTransact函数，作为Binder通信的服务端，处理来自BpCameraService发来的命令。

status_t BnCameraService::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    switch(code) {
        case GET_NUMBER_OF_CAMERAS: {
            CHECK_INTERFACE(ICameraService, data, reply);
            reply->writeInt32(getNumberOfCameras());
            return NO_ERROR;
        } break;
        case GET_CAMERA_INFO: {
            CHECK_INTERFACE(ICameraService, data, reply);
            CameraInfo cameraInfo;
            memset(&cameraInfo, 0, sizeof(cameraInfo));
            status_t result = getCameraInfo(data.readInt32(), &cameraInfo);
            reply->writeInt32(cameraInfo.facing);
            reply->writeInt32(cameraInfo.orientation);
            reply->writeInt32(result);
            return NO_ERROR;
        } break;
        case CONNECT: {
            CHECK_INTERFACE(ICameraService, data, reply);
            sp<ICameraClient> cameraClient = interface_cast<ICameraClient>(data.readStrongBinder());
            sp<ICamera> camera = connect(cameraClient, data.readInt32());
            reply->writeStrongBinder(camera->asBinder());
            return NO_ERROR;
        } break;
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}

注意onTransact()函数中调用的一些函数如：getNumOfCameras()， getCameraInfo()，  connect()等，我们在BpCameraService和BnCameraService的父类ICameraService中声明为纯虚函数，在BpCameraService和CameraService中分别给出了实现，BpCameraService作为代理类，提供接口给客户端，真正实现在BnCameraService的子类CameraService中。

class ICameraService : public IInterface
{
public:
    enum {
        GET_NUMBER_OF_CAMERAS = IBinder::FIRST_CALL_TRANSACTION,
        GET_CAMERA_INFO,
        CONNECT
    };

public:
    DECLARE_META_INTERFACE(CameraService);

    virtual int32_t         getNumberOfCameras() = 0;
    virtual status_t        getCameraInfo(int cameraId,
                                          struct CameraInfo* cameraInfo) = 0;
    virtual sp<ICamera>     connect(const sp<ICameraClient>& cameraClient,
                                    int cameraId) = 0;
};

宏声明：DECLARE_META_INTERFACE(CameraService)替换之后就是声明一些函数：

static const android::Strin16 descriptor;
static android::sp<ICameraService> asInterface(const android::sp<android::IBinder>& obj);
virtual const android::String16& getInterfaceDescriptor() const;
ICameraService();
virtual ICameraService();

宏实现：IMPLEMENT_META_INTERFACE(CameraService, "android.hardware.ICameraService")

static const android::Strin16 ICameraService::descriptor("android.hadrware.ICameraService");
static android::sp<ICameraService> ICameraServiec::asInterface(const android::sp<android::IBinder>& obj)
{
	android::sp<ICameraService> intr;
	if ( obj != NULL) {
		intr = static_cast<ICameraService*>(obj->queryLocalInterface(ICameraService::descriptor).get());
		if (intr == NULL){
			intr = new BpCameraService(obj);
		}
	}
	return intr;
}
virtual const android::String16& ICameraService::getInterfaceDescriptor() const
{
	return ICameraService::descriptor();
}
ICameraService() {}
virtual ICameraService() {}

BpCameraService 提供接口给客户端：

class BpCameraService: public BpInterface<ICameraService>
{
public:
    BpCameraService(const sp<IBinder>& impl)
        : BpInterface<ICameraService>(impl)
    {
    }

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

    // get information about a camera
    virtual status_t getCameraInfo(int cameraId,
                                   struct CameraInfo* cameraInfo) {
        Parcel data, reply;
        data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
        data.writeInt32(cameraId);
        remote()->transact(BnCameraService::GET_CAMERA_INFO, data, &reply);
        cameraInfo->facing = reply.readInt32();
        cameraInfo->orientation = reply.readInt32();
        return reply.readInt32();
    }

    // connect to camera service
    virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient, int cameraId)
    {
        Parcel data, reply;
        data.writeInterfaceToken(ICameraService::getInterfaceDescriptor());
        data.writeStrongBinder(cameraClient->asBinder());
        data.writeInt32(cameraId);
        remote()->transact(BnCameraService::CONNECT, data, &reply);
        return interface_cast<ICamera>(reply.readStrongBinder());
    }
};

到此现在我们已经在Binder服务中注册了我们的CameraService服务，并提供了给客户端的代理类BpCameraService。